[![Maven Central](https://img.shields.io/maven-central/v/io.stargate/stargate.svg?style=flat)](https://maven-badges.herokuapp.com/maven-central/io.stargate/stargate/)

# Stargate

An open source data API gateway.

Stargate is a data gateway deployed between client applications and a Cassandra database.
For developers, it makes it easy to use Cassandra for any application workload by adding plugin support for new APIs, data types, and access methods - even secondary database models.
It's built with extensibility as a first-class citizen to enable rapid innovation.
For operators, Stargate introduces microservice architecture, allowing independent deployment and scale of storage nodes, API Service nodes, and coordinator nodes in Cassandra clusters.

- For quick instructions on how to bring up Stargate on your desktop using Docker, check out the [Docker compose](docker-compose/README.md) instructions.
- If you wish to deploy in Kubernetes, there is also a [Helm chart](helm/README.md) you can use to install Stargate alongside an existing Cassandra cluster, or visit the [K8ssandra](https://k8ssandra.io) project for a distribution that packages Cassandra, Stargate, and additional tooling.
- For more information about how to deploy and use Stargate, visit [stargate.io](https://stargate.io/)
- To learn how to participate in our community, visit our [community page](https://stargate.io/community)
- To set up and use a Stargate development environment, see the instructions for the [coordinator](coordinator/README.md) and [APIs](apis/README.md).

## Contents
- [Introduction](#introduction)
- [Repositories](#repositories)
- [Issue Management](#issue-management)

## Introduction

We created Stargate because we got tired of using different databases and different APIs depending on the work that we were trying to get done.
With "read the manual" fatigue and lengthy selection processes wearing on us every time we started a new project, we thought - *why not create a framework that can serve many APIs for a range of workloads?*

This project enables customization of all aspects of data access and has modules for authentication, APIs, request handling / routing, and persistence backends.
The current form is specific to Apache Cassandra (C*) compatible backends.

As shown in the figure below, Stargate is often deployed behind a load balancer or proxy and exposes multiple endpoints to client applications, including HTTP APIs, gRPC, and the Cassandra Query Language (CQL). Stargate sits in front of a Cassandra cluster which is used as the storage backend.

![image](assets/stargate-arch-high-level.png#center)

Stargate consists of the following components, which we introduce briefly here with links to the corresponding modules in this monorepo.

### API Services
These are independently scalable microservices which various APIs, typically HTTP based. These modules can be found under the [apis](apis) directory:

- [sgv2-restapi](apis/sgv2-restapi): API implementation for exposing Cassandra data over REST
- [sgv2-graphqlapi](apis/sgv2-graphqlapi): API implementation for exposing Cassandra data over GraphQL
- [sgv2-docsapi](apis/sgv2-docsapi): API implementation for exposing Cassandra data over a Document API

Each API Service contains its own integration test suite that tests it against the coordinator node and supported Cassandra backends. There is also a [sgv2-quarkus-common](apis/sgv2-quarkus-common) module containing utilities that may be used by all Java/Quarkus based API services.

### Coordinator Node
Coordinator nodes participate as non-data storing nodes in the backing Cassandra cluster, which enables them to read and write data more efficiently. Stargate Coordinator nodes can also be scaled independently. Coordinator nodes expose gRPC and CQL interfaces for fast access by client applications. The following are the key modules comprising the coordinator and its exposed interfaces:

- [core](coordinator/core): Common classes used throughout the other coordinator modules
- [cql](coordinator/cql): API implementation for the Cassandra Query Language
- [grpc](coordinator/grpc): fast CQL over gRPC implementation (HTTP-based interface equivalent to CQL performance)
- [bridge](coordinator/bridge): gRPC-based interface used by API services
- [health-checker](coordinator/health-checker): HTTP endpoints useful for health checking coordinator nodes
- [metrics-jersey](coordinator/metrics-jersey): metrics collection for the coordinator node and its exposed interfaces
- [stargate-starter](coordinator/stargate-starter): the main Java application used to start the coordinator via the `starctl` script

#### Persistence Services
Stargate coordinator nodes support a pluggable approach for implementing the coordination layer to execute requests passed by API services and other interfaces to underlying data storage instances. Persistence service implementations are responsible handling and converting requests to database queries, dispatching to a specific version of Cassandra, and returning and serving responses.

- [persistence-api](coordinator/persistence-api): Interface for working with persistence services
- [persistence-common](coordinator/persistence-common): Utilities shared by the persistence services
- [persistence-cassandra-3.11](coordinator/persistence-cassandra-3.11): Joins C* 3.11 cluster as coordinator-only node (does not store data)
mocks C* system tables for native driver integration,
executes requests with C* storage nodes using C* QueryHandler/QueryProcessor,
converts internal C* objects and ResultSets to Stargate Datastore objects.
- [persistence-cassandra-4.0](coordinator/persistence-cassandra-4.0): (same as above but for Cassandra 4.0)
- [persistence-dse-6.8](coordinator/persistence-dse-6.8): (same as above but for DataStax Enterprise 6.8)

#### Authentication and Authorization Services
Stargate coordinator nodes also support a pluggable authentication and authorization approach.

- [authnz](coordinator/authnz): Interface for working with auth providers
- [auth-api](coordinator/auth-api): REST service for generating auth tokens
- [auth-table-based-service](coordinator/auth-table-based-service): Service to store tokens in the database
- [auth-jtw-service](coordinator/auth-jwt-service): Service to authenticate using externally generated JSON Web Tokens (JWTs)

#### Coordinator Node Testing
The following modules provide support for testing:

- [testing](coordinator/testing): Integration test suite for the coordinator node modules
- [testing](coordinator/testing-services): Testing helpers
- [persistence-test](coordinator/persistence-test): Common utilities for testing persistence services

Instructions for running and extending the test suite can be found in the [developer guide](DEV_GUIDE.md).

## Repositories

Here is an overview of the key repositories in the Stargate GitHub organization:

- [stargate/stargate](https://github.com/stargate/stargate): This repository is the primary entry point to the project. It is a monorepo containing all of the Stargate modules
- [stargate/docs](https://github.com/stargate/docs): This repository contains the user docs hosted on [stargate.io](https://stargate.io)
- [stargate/website](https://github.com/stargate/website): This repository contains the code for the website hosted on [stargate.io](https://stargate.io)

The organization also contains several gRPC client libraries for various languages.

## Issue Management

You can reference the [CONTRIBUTING.md](CONTRIBUTING.md) for a full description of how to get involved,
but the short of it is below.

- If you've found a bug (use the bug label) or want to request a new feature (use the enhancement label), file a GitHub issue
- If you're not sure about it or want to chat, reach out on our [Discord](https://discord.gg/GravUqY)
- If you want to write some user docs 🎉 head over to the [stargate/docs](https://github.com/stargate/docs) repo, Pull Requests accepted!

## Supported Versions and Branching Strategy

The Stargate project maintains support for the current major version number and one major version number previous. We mark the previous major version number as deprecated in order to encourage usage of the latest version. We anticipate supporting a major version number release N for one year after the subsequent major version number release (N+1), or until the major version number release (N+2), whichever comes first. For example, v1 will be supported until when Stargate v3 is released, but no later than October 2023 (1 year after release date of Stargate v2). We anticipate producing a new major version number release every 6-12 months.

Supporting a release entails making bug fixes, keeping dependencies up to date, and making sure Docker images are free from vulnerabilities.

The current major version is maintained on the default `main` branch. The prior major version number is maintained on a version branch, for example, `v1`.

We make bug fixes in all supported releases. The recommended approach is to commit a fix first to the previous major version branch (if applicable) and merge it forward into the current major version branch.

We use minor version numbers to indicate any changes to the coordinator that would cause compatibility changes for Stargate APIs. For example, a breaking change to the [bridge](coordinator/bridge) API in v2.0.x would cause creation of a v2.1.0 release, and any API implementations would need to explicitly update in order to be compatible. You can use any version of the coordinator and API that have same the major and minor version number without issues.

We iterate forward rather than producing patch releases. For example, for a vulnerability found in `v2.0.3`, we'd make any required fixes and dependency updates and release `v2.0.4`. We maintain a regular release cadence of approximately twice a month but can iterate more quickly as the situation dictates.

## Thanks

![YourKit Logo](https://www.yourkit.com/images/yklogo.png)

This project uses tools provided by YourKit, LLC. YourKit supports open source projects with its full-featured Java
Profiler. YourKit, LLC is the creator of YourKit Java Profiler and
YourKit .NET Profiler, innovative and intelligent tools for
profiling Java and .NET applications.


![banner](banner_dark.png#gh-dark-mode-only)
![banner](banner_light.png#gh-light-mode-only)

# Minestom

[![license](https://img.shields.io/github/license/Minestom/Minestom?style=for-the-badge&color=b2204c)](../LICENSE)
[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=for-the-badge)](https://github.com/RichardLitt/standard-readme)
[![javadocs](https://img.shields.io/badge/documentation-javadocs-4d7a97?style=for-the-badge)](https://javadoc.minestom.net)
[![wiki](https://img.shields.io/badge/documentation-wiki-74aad6?style=for-the-badge)](https://wiki.minestom.net/)
[![discord-banner](https://img.shields.io/discord/706185253441634317?label=discord&style=for-the-badge&color=7289da)](https://discord.gg/pkFRvqB)

Minestom is an open-source library that enables developers to create their own Minecraft server software, without any code from Mojang.

The main difference between Mojang's vanilla server and a minestom-based server, is that ours does not contain any features by default!
However, we have a complete API which is designed to allow you to make anything possible, with ease.

This is a developer API not meant to be used by end-users. Replacing Bukkit/Forge/Sponge with this **will not work** since we do not implement any of their APIs.

# Table of contents
- [Install](#install)
- [Usage](#usage)
- [Why Minestom?](#why-minestom)
- [Advantages & Disadvantages](#advantages-and-disadvantages)
- [API](#api)
- [Credits](#credits)
- [Contributing](#contributing)
- [License](#license)

# Install
Minestom is not installed like Bukkit/Forge/Sponge.
As Minestom is a Java library, it must be loaded the same way any other Java library may be loaded.
This means you need to add Minestom as a dependency, add your code and compile by yourself.

Minestom is available on [Maven Central](https://mvnrepository.com/artifact/net.minestom/minestom-snapshots),
and can be installed like the following (Gradle/Groovy):

```groovy
repositories {
    mavenCentral()
    maven { url 'https://jitpack.io' }
}

dependencies {
    implementation 'net.minestom:minestom-snapshots:<???>'
}
```

# Usage
An example of how to use the Minestom library is available [here](/demo).
Alternatively you can check the official [wiki](https://wiki.minestom.net/) or the [javadocs](https://minestom.github.io/Minestom/).

# Why Minestom?
Minecraft has evolved a lot since its release, most of the servers today do not take advantage of vanilla features and even have to struggle because of them.
Our target audience is those who want to make a server that benefits little from vanilla features. e.g. creative, kitpvp.
The goal is to offer more performance for those who need it.
In other words, it makes sense to use Minestom when it takes less time to implement every missing vanilla feature you want than removing every vanilla feature that will slow you down.

# Advantages and Disadvantages
Minestom isn't perfect, our choices make it much better for some cases, worse for some others.

## Advantages
* Remove the overhead of vanilla features
* Multi-threaded
* Instance system (Collections of blocks and entities) which is much more scalable than worlds
* Open-source
* Modern API
* No more legacy NMS

## Disadvantages
* Does not work with Bukkit/Forge/Sponge plugins or mods
* Does not work with older clients (using a proxy with ViaBackwards is possible)
* Bad for those who want a vanilla experience
* Longer to develop something playable
* Multi-threaded environments need extra consideration

# API
Even if we do not include anything by default in the game, we simplify the way you add them, here is a preview.

## Instances
It is our major concept, worlds are great for survival with friends, but when it scales up it can become unmanageable. The best examples can be found in Skyblock or minigames, not being able to separate each part properly and being forced to save everything in files, not to say the overhead caused by unnecessary data contained in them. Instances are a lightweight solution to it, being able to have every chunk in memory only, copying and sending it to another player in no time, with custom serialization and much more...

Being able to create instances directly on the go is a must-have, we believe it can push many more projects forward.

Instances also come with performance benefits, unlike some others which will be fully single-threaded or maybe using one thread per world we are using a set number of threads (pool) to manage all chunks independently from instances, meaning using more CPU power.

## Blocks
Minestom by default does not know what is a chest, you will have to tell him that it opens an inventory.
Every "special blocks" (which aren't only visual) need a specialized handler. After applying this handler, you have a block that can be placed anywhere simply.
However, all blocks are visually there, they just won't have interaction by default.

## Entities
The terms "passive" or "aggressive" monsters do not exist, nobody stops you from making a flying chicken rushing into any players coming too close, doing so with NMS is a real mess because of obfuscation and the large inheritance.

## Inventories
It is a field where Minecraft evolved a lot, inventories are now used a lot as client<->server interface with clickable items and callback, we support these interactions natively without the need of programming your solution.

## Commands
Commands are the simplest way of communication between clients and server. Since 1.13 Minecraft has incorporated a new library denominated "Brigadier", we then integrated an API designed to use the full potential of args types.

# Credits
* The [contributors](https://github.com/Minestom/Minestom/graphs/contributors) of the project
* [The Minecraft Coalition](https://wiki.vg/) and [`#mcdevs`](https://github.com/mcdevs) -
   protocol and file formats research.
* [The Minecraft Wiki](https://minecraft.wiki) for all their useful info
* [JProfiler](https://www.ej-technologies.com/products/jprofiler/overview.html) for their amazing Java profiler

# Contributing
See [the contributing file](CONTRIBUTING.md)!
All WIP features are previewed as Draft PRs

# License
This project is licensed under the [Apache License Version 2.0](../LICENSE).


# teku

 [![Build Status](https://circleci.com/gh/Consensys/teku.svg?style=svg)](https://circleci.com/gh/Consensys/workflows/teku)
 [![GitHub License](https://img.shields.io/github/license/Consensys/teku.svg?logo=apache)](https://github.com/Consensys/teku/blob/master/LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-readme-blue?logo=readme&logoColor=white)](https://docs.teku.consensys.io/)
 [![Discord](https://img.shields.io/badge/Chat-on%20Discord-%235865F2?logo=discord&logoColor=white)](https://discord.gg/7hPv2T6)
 [![Twitter Follow](https://img.shields.io/twitter/follow/Teku_Consensys)](https://twitter.com/Teku_Consensys)
 [![GitPOAP Badge](https://public-api.gitpoap.io/v1/repo/ConsenSys/teku/badge)](https://www.gitpoap.io/gh/ConsenSys/teku)

Teku is an open-source Ethereum consensus client written in Java and containing a full beacon node and validator client implementation.

See the [Changelog](https://github.com/Consensys/teku/releases) for details of the latest releases and upcoming breaking changes.

## Useful links

* [Ethereum Beacon Chain specification](https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md)
* [Teku user documentation](https://docs.teku.consensys.net/)
* [Teku REST API reference documentation](https://consensys.github.io/teku/)
* [Teku issues](https://github.com/Consensys/teku/issues)
* [Contribution guidelines](CONTRIBUTING.md)
* [Teku Changelog](https://github.com/Consensys/teku/releases)

## Teku users

See our [user documentation](https://docs.teku.consensys.net/).

Raise a [documentation issue](https://github.com/Consensys/doc.teku/issues) or get in touch in
the #teku channel on [Discord](https://discord.gg/7hPv2T6) if you've got questions or feedback.

## Teku developers

* [Contribution Guidelines](CONTRIBUTING.md)
* [Coding Conventions](https://wiki.hyperledger.org/display/BESU/Coding+Conventions)

## Binary Releases

Binary releases are available from the [releases page](https://github.com/Consensys/teku/releases).
Binary builds that track the latest changes on the master branch are available on
[Dockerhub](https://hub.docker.com/r/consensys/teku) using the `develop` version or as binary
downloads ([tar.gz format](https://artifacts.consensys.net/public/teku/raw/names/teku.tar.gz/versions/develop/teku-develop.tar.gz)
or [zip format](https://artifacts.consensys.net/public/teku/raw/names/teku.zip/versions/develop/teku-develop.zip)).

We recommend only using release versions for Mainnet, but `develop` builds are useful for testing
the latest changes on testnets.

Release notifications are available via:
* Sign up to our [release announcements](https://pages.consensys.net/teku-sign-up) email list (release and important announcements only, no marketing)
* Follow us on [Twitter](https://twitter.com/Teku_Consensys)
* `teku` in [Consensys Discord](https://discord.gg/7hPv2T6),
* Subscribe to release notifications on github for [teku](https://github.com/Consensys/teku)

## Build Instructions

### Install Prerequisites

* Java 17+

Note: Official builds of Teku are performed with Java 17.
Building on a more recent version of Java is supported, but the resulting build will not work on earlier versions of Java.

### Build and Dist

To create a ready to run distribution:

```shell script
git clone https://github.com/Consensys/teku.git
cd teku && ./gradlew distTar installDist
```

This produces:
- Fully packaged distribution in `build/distributions`
- Expanded distribution, ready to run in `build/install/teku`

### Build and Test

To build, clone this repo and run with `gradle`:

```shell script
git clone https://github.com/Consensys/teku.git
cd teku && ./gradlew

```

After a successful build, distribution packages are available in `build/distributions`.

### Other Useful Gradle Targets

| Target      | Builds                                                  |
|-------------|---------------------------------------------------------|
| distTar     | Full distribution in build/distributions (as `.tar.gz`) |
| distZip     | Full distribution in build/distributions (as `.zip`)    |
| installDist | Expanded distribution in `build/install/teku`           |
| distDocker  | The `consensys/teku` docker image                       |

## Code Style

We use Google's Java coding conventions for the project. To reformat code, run:

```shell script
./gradlew spotlessApply
```

Code style is checked automatically during a build.

## Testing

All the unit tests are run as part of the build, but can be explicitly triggered with:

```shell script
./gradlew test
```

## Special thanks
YourKit for providing us with a free profiler open source license.

YourKit supports open source projects with innovative and intelligent tools
for monitoring and profiling Java and .NET applications.
YourKit is the creator of YourKit Java Profiler,
YourKit .NET Profiler,
and YourKit YouMonitor.

![YourKit Logo](https://www.yourkit.com/images/yklogo.png)


= Apache Camel extensions for Quarkus

image:https://img.shields.io/maven-central/v/org.apache.camel.quarkus/camel-quarkus-bom.svg["Maven Central", link="http://search.maven.org/#search%7Cga%7C1%7Corg.apache.camel.quarkus"]
image:https://img.shields.io/github/license/openshift/origin.svg?maxAge=2592000["Licensed under Apache License version 2.0", link="https://www.apache.org/licenses/LICENSE-2.0"]
image:https://img.shields.io/badge/zulip-join_chat-brightgreen.svg["Chat on Zulip", link="https://camel.zulipchat.com"]

==== CI Branch Status
[width="50%"]
|===
|main | image:https://github.com/apache/camel-quarkus/actions/workflows/ci-build.yaml/badge.svg?branch=main["Main Branch Build", link="https://github.com/apache/camel-quarkus/actions?query=workflow%3A%22Camel+Quarkus+CI%22"]
|camel-main | image:https://github.com/apache/camel-quarkus/actions/workflows/ci-build.yaml/badge.svg?branch=camel-main["Camel Main Branch Build", link="https://github.com/apache/camel-quarkus/actions?query=workflow%3A%22Camel+Quarkus+CI%22+branch%3Acamel-main"]
|quarkus-main| image:https://github.com/apache/camel-quarkus/actions/workflows/ci-build.yaml/badge.svg?branch=quarkus-main["Quarkus Main Branch Build", link="https://github.com/apache/camel-quarkus/actions?query=workflow%3A%22Camel+Quarkus+CI%22+branch%3Aquarkus-main"]
|===

== What is this

This project hosts the efforts to port and package the 300+ Camel components as Quarkus extensions.

http://camel.apache.org/[Apache Camel] is the Swiss knife of integrating heterogeneous systems with more than a decade
of history and a lively community of users and developers.

https://camel.apache.org/manual/getting-started.html[Getting started with Camel] is user guide to start with Camel in general.

https://quarkus.io/[Quarkus] is a Java platform offering fast boot times and low memory footprint. It targets both stock
JVMs (OpenJDK in the first place) and https://www.graalvm.org/[GraalVM].

https://quarkus.io/extensions/[Quarkus extensions] are units of Quarkus distribution. They configure, boot and integrate
a technology (in our case Camel components) into your Quarkus application. You will typically use them as dependencies
in your project.

== How to build

See the contributor guide xref:docs/modules/ROOT/pages/contributor-guide/index.adoc[in the source tree] or on the
https://camel.apache.org/camel-quarkus/latest/contributor-guide/index.html[Apache Camel website].

== Licensing

This software is licensed under the terms you may find in the file named `LICENSE.txt` in this directory.


## Amplify for Android
<img src="https://s3.amazonaws.com/aws-mobile-hub-images/aws-amplify-logo.png" alt="AWS Amplify" width="550">

[![DiscordChat](https://img.shields.io/discord/308323056592486420?logo=discord)](https://discord.gg/jWVbPfC)
[![GitHub release](https://img.shields.io/github/release/aws-amplify/amplify-android.svg)](https://github.com/aws-amplify/amplify-android/releases)
[![Maven Central](https://img.shields.io/maven-central/v/com.amplifyframework/core.svg)](https://search.maven.org/search?q=g:com.amplifyframework%20a:core)
-------------------------------------------------------

The Amplify Android library is AWS' preferred mechanism for interacting
with AWS services from an Android device.

The library provides a high-level interface to perform different
**categories** of cloud operations. Each category may be fulfilled by a
**plugin**, which you configure during setup.

The default plugins that we provide are designed to facilitate
interaction with Amazon Web Services (AWS). But, the Amplify Framework
is designed to be extensible to any other backend or service.

To familiarize yourself with Amplify, checkout our [Getting Started
Guide](https://docs.amplify.aws/start/q/integration/android).

## Categories

| Category                                                                                | AWS Provider | Description                                                                                |
|--------------------------------------------------------------------------------------------------------------|--------------|-----------------------------------------------------------------------------------------------|
| **[Authentication](https://docs.amplify.aws/lib/devpreview/getting-started/q/platform/android)**             | Cognito      | Building blocks to create auth experiences                                                    |
| **[Storage](https://docs.amplify.aws/lib/storage/getting-started/q/platform/android)**                       | S3           | Manages content in public, protected, private storage buckets                                 |
| **[DataStore](https://docs.amplify.aws/lib/datastore/getting-started/q/platform/android)**                   | AppSync      | Programming model for shared and distributed data, with simple online/offline synchronization |
| **[API (GraphQL)](https://docs.amplify.aws/lib/graphqlapi/getting-started/q/platform/android)**              | AppSync      | Interact with your GraphQL or AppSync endpoint                                                |
| **[API (REST)](https://docs.amplify.aws/lib/restapi/getting-started/q/platform/android)**                    | API Gateway  | Sigv4 signing and AWS auth for API Gateway and other REST endpoints                           |
| **[Analytics](https://docs.amplify.aws/lib/analytics/getting-started/q/platform/android)**                   | Pinpoint     | Collect Analytics data for your app including tracking user sessions                          |
| **[Geo](https://docs.amplify.aws/lib/geo/getting-started/q/platform/android)**                               | Location     | Add maps to your app with APIs and map UI components                                          |
| **[Predictions](https://docs.amplify.aws/lib/predictions/getting-started/q/platform/android)**               | Various*     | Connect your app with machine learning services like NLP, computer vision, TTS, and more.     |
| **[Push Notifications](https://docs.amplify.aws/lib/push-notifications/getting-started/q/platform/android)** | Pinpoint     | Segment users, trigger push notifications, and record metrics                                 |

\* Predictions utilizes a range of Amazon's Machine Learning services,
including: Amazon Comprehend, Amazon Polly, Amazon Rekognition, Amazon
Textract, and Amazon Translate.

All services and features not listed above are supported via the [Kotlin SDK](https://github.com/awslabs/aws-sdk-kotlin) or if supported by a category can be accessed via the Escape Hatch like below:

### Kotlin

```kotlin
val s3StoragePlugin = Amplify.Storage.getPlugin("awsS3StoragePlugin")
val s3Client = s3StoragePlugin.escapeHatch as S3Client
```

### Java

```java
AWSS3StoragePlugin plugin = (AWSS3StoragePlugin) Amplify.Storage.getPlugin("awsS3StoragePlugin");
S3Client s3Client = plugin.getEscapeHatch();
```

## Platform Support

The Amplify Framework supports Android API level 24 (Android 7.0) and above.

## Using Amplify from Your App

For step-by-step setup instructions, checkout our [Project Setup
guide](https://docs.amplify.aws/lib/project-setup/prereq/q/platform/android).

### Specifying Gradle Dependencies

To begin, include Amplify from your `app` module's `build.gradle`
dependencies section:

```groovy
dependencies {
    // Only specify modules that provide functionality your app will use
    implementation 'com.amplifyframework:aws-analytics-pinpoint:2.19.1'
    implementation 'com.amplifyframework:aws-api:2.19.1'
    implementation 'com.amplifyframework:aws-auth-cognito:2.19.1'
    implementation 'com.amplifyframework:aws-datastore:2.19.1'
    implementation 'com.amplifyframework:aws-predictions:2.19.1'
    implementation 'com.amplifyframework:aws-storage-s3:2.19.1'
    implementation 'com.amplifyframework:aws-geo-location:2.19.1'
    implementation 'com.amplifyframework:aws-push-notifications-pinpoint:2.19.1'
}
```

### Java 8 Requirement

Amplify Android _requires_ Java 8 features. Please add a `compileOptions`
block inside your app's `build.gradle`, as below:

```gradle
android {
    compileOptions {
        coreLibraryDesugaringEnabled true
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }
}
```
In the same file, add core library desugaring in your `dependencies`
block:
```gradle
dependencies {
    // Add this line
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.0.10'
}
```

### Kotlin & Rx Support

Amplify's default interface renders results through async callbacks. We also provide optional, adapter APIs which better integrate with RxJava and Kotlin:

 - [Using RxJava with Amplify](https://docs.amplify.aws/lib/project-setup/rxjava/q/platform/android)
 - [Kotlin Coroutines Support](https://docs.amplify.aws/lib/project-setup/coroutines/q/platform/android)

### Semantic versioning

We follow [semantic versioning](https://semver.org/) for our releases.

#### Semantic versioning and enumeration cases

When Amplify adds a new a new enumeration class entry or sealed class subtype, we
will publish a new **minor** version of the library.

Applications that use a `when` expression to evaluate all members of an enumerated
type can add an `else` branch to prevent new cases from causing compile warnings
 or errors.

#### Semantic versioning and dependencies update

We follow [semantic versioning for updating our dependencies](https://semver.org/#what-should-i-do-if-i-update-my-own-dependencies-without-changing-the-public-api). This includes updating the Kotlin language version.

## License

This library is licensed under the [Apache 2.0 License](./LICENSE).

## Report a Bug

[![Open Bugs](https://img.shields.io/github/issues/aws-amplify/amplify-android/bug?color=d73a4a&label=bugs)](https://github.com/aws-amplify/amplify-android/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
[![Open Questions](https://img.shields.io/github/issues/aws-amplify/amplify-android/question?color=558dfd&label=questions)](https://github.com/aws-amplify/amplify-android/issues?q=is%3Aissue+label%3A%22question%22+is%3Aopen)
[![Feature Requests](https://img.shields.io/github/issues/aws-amplify/amplify-android/feature-request?color=ff9001&label=feature%20requests)](https://github.com/aws-amplify/amplify-android/issues?q=is%3Aissue+label%3A%22feature-request%22+is%3Aopen+)
[![Closed Issues](https://img.shields.io/github/issues-closed/aws-amplify/amplify-android?color=%2325CC00)](https://github.com/aws-amplify/amplify-android/issues?q=is%3Aissue+is%3Aclosed+)

We appreciate your feedback – comments, questions, and bug reports. Please
[submit a GitHub issue](https://github.com/aws-amplify/amplify-android/issues),
and we'll get back to you.

## Contribute to the Project

We welcome any and all contributions from the community! Make sure you read through our [Contribution Guidelines](./CONTRIBUTING.md) before submitting any PR's. Thanks! ♥


# Azure SDK for Android

This repository is for active development of the Azure SDK for Android. For consumers of the SDK we recommend visiting our versioned [developer docs](https://azure.github.io/azure-sdk-for-android).

> Note: The Azure SDK for Android replaces a previous offering, known as Azure.Android. Source code and documentation for Azure.Android is available in the [Azure.Android](https://github.com/Azure/azure-sdk-for-android/tree/Azure.Android) branch.

## Getting started

For your convenience, each service has a separate set of libraries that you can choose to use instead of one, large Azure package. To get started with a specific library, see the **README.md** file located in the library's project folder. You can find service libraries in the `/sdk` directory.

### Prerequisites

* The libraries are written in Java 8. Your application must be built with Android Gradle Plugin 3.0.0 or later, and must be configured to [enable Java 8 language desugaring](https://developer.android.com/studio/write/java8-support.html#supported_features) to use these libraries. Any Java 8+ APIs that would require the Java 8+ API desugaring provided by Android Gradle plugin 4.0.0 are not used.
* You must have an [Azure subscription](https://azure.microsoft.com/free/) to use these libraries.

### Libraries available

Currently, the client libraries are in **beta**. These libraries follow the [Azure SDK Design Guidelines for Android](https://azure.github.io/azure-sdk/android_design.html) and share a number of core features such as HTTP retries, logging, transport protocols, authentication protocols, etc., so that once you learn how to use these features in one client library, you will know how to use them in other client libraries. You can learn about these shared features in [azure-core](https://github.com/Azure/azure-sdk-for-android/blob/main/sdk/core/azure-core/README.md).

The following libraries are currently in **beta**:

#### Core
- [azure-core](https://github.com/Azure/azure-sdk-for-android/blob/main/sdk/core/azure-core): 1.0.0-beta.12
- [azure-core-logging](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-logging): 1.0.0-beta.12
- [azure-core-http](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-http): 1.0.0-beta.12
- [azure-core-http-okhttp](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-http-okhttp): 1.0.0-beta.12
- [azure-core-http-httpurlconnection](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-http-httpurlconnection): 1.0.0-beta.12
- [azure-core-jackson](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-jackson): 1.0.0-beta.12
- [azure-core-rest](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-rest): 1.0.0-beta.12
- [azure-core-credentials](https://github.com/Azure/azure-sdk-for-android/tree/main/sdk/core/azure-core-credential): 1.0.0-beta.12

> Note: The SDK is currently in **beta**. The API surface and feature sets are subject to change at any time before they become generally available. We do not currently recommend them for production use.

The following libraries are currently **generally available**:

#### Azure Communication Services
- [azure-communication-calling](https://search.maven.org/artifact/com.azure.android/azure-communication-calling): 2.2.1
- [azure-communication-chat](https://github.com/Azure/azure-sdk-for-android/blob/main/sdk/communication/azure-communication-chat): 2.0.0
- [azure-communication-common](https://github.com/Azure/azure-sdk-for-android/blob/main/sdk/communication/azure-communication-common): 1.0.2

### Install the libraries
To install the Azure client libraries for Android, add them as dependencies within your
[Gradle](#add-a-dependency-with-gradle) or
[Maven](#add-a-dependency-with-maven) build scripts.

#### Add a dependency with Gradle
To import one or more client libraries into your project using the [Gradle](https://gradle.org/) build system, follow the instructions in [Add build dependencies](https://developer.android.com/studio/build/dependencies):

For each library you wish to use, add an `implementation` configuration to the `dependencies` block of your app's `build.gradle` or `build.gradle.kts` file, specifying the library's name and version:

```gradle
// build.gradle
dependencies {
    ...
    implementation "com.azure.android:azure-communication-chat:2.0.0"
}

// build.gradle.kts
dependencies {
    ...
    implementation("com.azure.android:azure-communication-chat:2.0.0")
}
```

#### Add a dependency with Maven
To import one or more client libraries into your project using the [Maven](https://maven.apache.org/) build system, add them to the `dependencies` section of your app's `pom.xml` file, specifying the artifact ID and version of each library you wish to use:

```xml
<dependency>
  <groupId>com.azure.android</groupId>
  <artifactId>azure-communication-chat</artifactId>
  <version>2.0.0</version>
</dependency>
```

## Need help?

* File an issue via [Github Issues](https://github.com/Azure/azure-sdk-for-android/issues/new/choose).
* Check [previous questions](https://stackoverflow.com/questions/tagged/azure-android-sdk) or ask new ones on StackOverflow using `azure-android-sdk` tag.

### Reporting security issues and security bugs

Security issues and bugs should be reported privately, via email, to the Microsoft Security Response Center (MSRC) <secure@microsoft.com>. You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Further information, including the MSRC PGP key, can be found in the [Security TechCenter](https://www.microsoft.com/msrc/faqs-report-an-issue).

## Contributing
For details on contributing to this repository, see the [contributing guide](https://github.com/Azure/azure-sdk-for-android/blob/main/CONTRIBUTING.md).

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit
https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repositories using our CLA.

This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-android%2FREADME.png)


[![Node: Build Application](https://github.com/hashgraph/hedera-services/actions/workflows/node-flow-build-application.yaml/badge.svg)](https://github.com/hashgraph/hedera-services/actions/workflows/node-flow-build-application.yaml)
[![Artifact Determinism](https://github.com/hashgraph/hedera-services/actions/workflows/flow-artifact-determinism.yaml/badge.svg)](https://github.com/hashgraph/hedera-services/actions/workflows/flow-artifact-determinism.yaml)
[![Node: Performance Tests](https://github.com/hashgraph/hedera-services/actions/workflows/flow-node-performance-tests.yaml/badge.svg)](https://github.com/hashgraph/hedera-services/actions/workflows/flow-node-performance-tests.yaml)

[![codecov](https://codecov.io/gh/hashgraph/hedera-services/graph/badge.svg?token=ZPMV8C93DV)](https://codecov.io/gh/hashgraph/hedera-services)
[![Latest Version](https://img.shields.io/github/v/tag/hashgraph/hedera-services?sort=semver&label=version)](README.md)
[![Made With](https://img.shields.io/badge/made_with-java-blue)](https://github.com/hashgraph/hedera-services/)
[![Development Branch](https://img.shields.io/badge/docs-quickstart-green.svg)](docs/gradle-quickstart.md)
[![License](https://img.shields.io/badge/license-apache2-blue.svg)](LICENSE)

# Hedera Services

Implementation of the Platform and the [services offered](https://github.com/hashgraph/hedera-protobufs) by
nodes in the [Hedera public network](https://hedera.com).

## Overview of child modules
* _platform-sdk/_ - the basic Platform – [documentation](platform-sdk/docs/platformWiki.md)
* _hedera-node/_ - implementation of Hedera services on the Platform – [documentation](hedera-node/docs/)

## Getting Started

Refer to the [Quickstart Guide](docs/README.md) for how to work with this project.

## Solidity
Hedera Contracts support `pragma solidity <=0.8.9`.

## Support

If you have a question on how to use the product, please see our
[support guide](https://github.com/hashgraph/.github/blob/main/SUPPORT.md).

## Contributing

Contributions are welcome. Please see the [contributing guide](https://github.com/hashgraph/.github/blob/main/CONTRIBUTING.md) to see how you can get involved.

## Code of Conduct

This project is governed by the [Contributor Covenant Code of Conduct](https://github.com/hashgraph/.github/blob/main/CODE_OF_CONDUCT.md). By participating, you are
expected to uphold this code of conduct.

## License

[Apache License 2.0](LICENSE)


[![Build](https://github.com/hashgraph/hedera-mirror-node/actions/workflows/gradle.yml/badge.svg)](https://github.com/hashgraph/hedera-mirror-node/actions)
[![codecov](https://img.shields.io/codecov/c/github/hashgraph/hedera-mirror-node/main)](https://codecov.io/gh/hashgraph/hedera-mirror-node)
[![Discord](https://img.shields.io/badge/discord-join%20chat-blue.svg)](https://hedera.com/discord)

# Hedera Mirror Node

The Hedera Mirror Node acts as an archive node and stores historical data for the Hedera network.

## Overview

Mirror nodes receive information from the Hedera nodes and can provide value-added services such as APIs, auditing,
analytics, visibility services, security threat modeling, data monetization services, etc. Mirror nodes can also run
additional business logic to support applications built using the Hedera network.

While mirror nodes receive information from the main nodes, they do not contribute to consensus on the network, and
their votes are not counted. Only the votes from the main nodes are counted for determining consensus. The trust of the
Hedera network is derived based on the consensus reached by the main nodes. That trust is transferred to the mirror
nodes using cryptographic signatures on a chain of files.

Eventually, the mirror nodes will be able to run the same code as the Hedera nodes so that they can see the transactions
in real time. To make the initial deployments easier, the mirror node strives to take away the burden of running a full
Hedera node through creation of periodic files that contain processed information (such as account balances or
transaction records), and have the full trust of the main nodes. The mirror node software reduces the processing burden
by receiving pre-constructed files from the network, validating those, populating a database, and providing APIs to
expose the data. This approach provides the following advantages:

- Lower compute and bandwidth requirements
- Allows users to only save the data that they care about (lower storage requirement)
- Easy searchable database so the users can add value quickly
- Easy to consume APIs to make integrations faster

## Architecture

### Main Nodes

- When a transaction reaches consensus, Hedera nodes add the transaction and its associated record to a
  [record file](https://github.com/hashgraph/hedera-protobufs/blob/main/streams/record_stream_file.proto).
- Record files contain the hash of the previous record file, thus creating an unbreakable validation chain.
- The file is closed on a regular cadence and a signature file is generated by the node for the record file.
- The record and signature files from each node are then uploaded to Amazon S3 and Google Cloud Storage.

### Mirror Nodes

- This mirror node software downloads signature files from cloud storage.
- The signature files are verified using the corresponding node's public key from the address book (stored in
  a `0.0.102` file).
- The verified signature files are checked to ensure at least 1/3 have the same record file hash.
- For each valid signature file, the corresponding record file is then downloaded from cloud storage and its hash is
  verified against the hash contained in the signature file.
- The downloaded record file contains a previous hash that is validated against the last processed file to verify the
  hash chain.
- Record files can then be processed and transactions and records processed for long term storage.

## Getting Started

### Prerequisite Tools

Ensure these tools are installed (note minimum versions) prior to running the mirror node:

- [Docker Desktop 4.28+](https://www.docker.com/products/docker-desktop)

### Running

For production use, we recommend using Kubernetes and to deploy using our Helm [chart](charts). Hedera managed mirror
nodes use Kubernetes and Helm for their deployments, and this process is considered the most production-ready. As an
alternative for local development, Docker Compose can be used to run the mirror node. See
the [installation](docs/installation.md#running-via-docker-compose) document for more details on configuring and running
with Docker Compose. To get up and running quickly with Docker Compose execute the following commands in your terminal:

```bash
git clone https://github.com/hashgraph/hedera-mirror-node.git
cd hedera-mirror-node
docker compose up
```

> **_NOTE:_** This defaults to a bucket setup for demonstration purposes. See the next section for more details.

## Data Access

### Demo

The free option utilizes a bucket setup for demonstration purposes. This is not a real Hedera network but simply a dummy
bucket populated with a day's worth of past testnet data. This is the default option and requires no additional steps.
Once you've verified your deployment works against the demo bucket, remember to configure it with
a [public network](#public-networks) then wipe the database and restart the mirror node.

### Public Networks

To access data from real Hedera networks,
[AWS](https://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html) or
[GCS](https://cloud.google.com/storage/docs/requester-pays) requester pays credentials must be used. The charges
associated with the downloading of stream files are paid for by the requester and not the bucket owner. See
the [Run Your Own Mirror Node](https://docs.hedera.com/hedera/core-concepts/mirror-nodes/run-your-own-beta-mirror-node)
documentation for more information.

## Documentation

- Components
  - [GraphQL API](docs/graphql/README.md)
  - [gRPC API](docs/grpc/README.md)
  - [Importer](docs/importer/README.md)
  - [Monitor](docs/monitor/README.md)
  - [REST API](docs/rest/README.md)
  - [REST Java API](docs/rest-java/README.md)
  - [Rosetta API](docs/rosetta/README.md)
  - [Web3 API](docs/web3/README.md)
- [Configuration](docs/configuration.md)
- [Contributing](docs/contributing.md)
- [Installation](docs/installation.md)
- [Troubleshooting](docs/troubleshooting.md)

## Releasing

To perform a new release, run the `Automated Release` GitHub workflow.

## Support

If you have a question on how to use the product, please see our
[support guide](https://github.com/hashgraph/.github/blob/main/SUPPORT.md).

## Contributing

Contributions are welcome. Please see the [contributing guide](docs/contributing.md) to see how you can get involved.

## Code of Conduct

This project is governed by the
[Contributor Covenant Code of Conduct](https://github.com/hashgraph/.github/blob/main/CODE_OF_CONDUCT.md). By
participating, you are expected to uphold this code of conduct. Please report unacceptable behavior
to [oss@hedera.com](mailto:oss@hedera.com).

## License

[Apache License 2.0](LICENSE)


# Clava
Clava is a C/C++/CUDA/OpenCL source-to-source compiler. It applies analysis and transformations written in JavaScript scripts, and can be installed in under a minute.

If you have used Clava, please consider filling the [Clava User Experience Feedback form](https://forms.gle/SioZSAv1KL7XpQ5j6) (it's short, really!)

Clava also supports LARA files (`.lara`), but the LARA DSL is now considered legacy, please use JavaScript instead.

# Compatibility

Currently Clava requires Java 11.

Although Clava is mainly a Java program, which should run on any compatible Java runtime, it also uses compiled binaries. These have operating system restrictions. Currently Clava is supported in Windows 10, Ubuntu 20.04, CentOS 7 and MacOS 11 (Big Sur).

# Quickstart

<!--
[Clava Tutorial - 2018 PACT](https://github.com/specs-feup/specs-lara/tree/master/2018-PACT) - Tutorial on how to use Clava (recommended parts 1-3).
-->

<!--
[LARA Reference Guide](https://web.fe.up.pt/~specs/wiki/doku.php?id=doc:lara) - Start using LARA with examples.
-->

[Clava Web-based Tutorial - 2022](https://specs.fe.up.pt/tools/clava/Clava%20Web-based%20Tutorial%20(2022).pdf) - Tutorial on how to use Clava, based on the online demo version.

[Language Specification](https://specs.fe.up.pt/tools/clava/language_specification.html) - List of all join points, attributes and actions available in Clava.

[API Documentation](https://specs-feup.github.io/clava/api/) - List of LARA APIs available in Clava.

[API Slides](https://drive.google.com/drive/u/1/folders/1IAqv7SpP8S-t5g3fpNO06cJ7J2j2aD7K) - Introduction to Clava and the LARA Framework APIs.

For a sample of Clava examples, please check the [Unit Tests](https://github.com/specs-feup/clava/tree/master/ClavaWeaver/resources/clava/test).

# Installing

A ZIP file with the last compiled JAR for Clava can be downloaded from [here](http://specs.fe.up.pt/tools/clava.zip) ([previous releases](https://drive.google.com/drive/folders/1X3JeYB783ZfqoqIYrCitqABDWhM5bV_Y?usp=sharing)).

There is an [installation script](http://specs.fe.up.pt/tools/clava/clava-update) for Linux that can be run locally and that will install the Clava binary in the script path (sudo is required for CMake module installation).

For an online demo version of Clava, please click [here](http://specs.fe.up.pt/tools/clava/).

To call Clava from within CMake, please click [here](https://github.com/specs-feup/clava/tree/master/CMake).

To build Clava, please check the [ClavaWeaver](https://github.com/specs-feup/clava/tree/master/ClavaWeaver) project folder.

# Running Clava

Clava can be run from CMake, using a GUI, or as a command-line tool.

## CMake

Instructions for the Clava CMake plugin can be found [here](https://github.com/specs-feup/clava/tree/master/CMake).

## GUI

Run the JAR with passing parameters, e.g.:

	java -jar Clava.jar

A video demonstrating the GUI can be found [here](https://www.youtube.com/watch?v=IFvNWYCivFA).

## Command Line

There are two main modes in command line, either passing all arguments (LARA file, parameters, etc...), or passing a configuration file that was built with the graphical user interface.

### Using parameters:

	java -jar Clava.jar <aspect.lara> -p <source_folder>

where <aspect.lara> is the LARA aspect you want to execute, and <source_folder> is the folder where the source code is.

There are more command-line options available, which can be consulted by running:

	java -jar Clava.jar --help

### Configuration file:

To pass a configuration file, use the flag -c:

	java -jar Clava.jar -c <config.clava>

where <config.clava> is the configuration file created with the GUI.

## Server Mode

For short executions, most of the execution time is related to starting a JVM.

There is an experimental feature where you can call Clava in server mode. In this mode, Clava can run in the background and will wait for requests. Then you can use a compiled program that performs requests to the server.

To start Clava in server mode, use the flag -server:

	java -jar Clava.jar -server

The Linux instalation script provides the `clavaw` program, which sends a request to a Clava server:

        clavaw <Clava flags>

### Limitations

- Only absolute paths are supported in this mode, since the server will use its own folder as the working folder. However, files defined in config files should be handled automatically, they are converted to absolute paths, using the folder of the config file as the base folder. Additionally, if inside a Lara script you need to use files, you can use `Clava.getData().getContextFolder()` (`import clava.Clava;`) to return the folder of the config file.
- The output of the program will appear on the terminal of the server, not where `clavaw` runs-

# Troubleshooting

## Error 'Invalid or corrupt jarfile'

Check if you have at least Java 11 installed, this is the minimum version.

## Error 'missing libtinfo.so.5'

On Fedora >28 systems this can be solved by installing the package `ncurses-compat-libs`

## Error 'cannot find -lz'

Install libz package (e.g., in Ubuntu `sudo apt-get install libz-dev`)

# Citing Clava

If you want to reference Clava in your work, please use the following publication:

*João Bispo, and João MP Cardoso. Clava: C/C++ source-to-source compilation using LARA. SoftwareX, Volume 12, 2020, Article 100565.* [[ScienceDirect](https://www.sciencedirect.com/science/article/pii/S2352711019302122)] [[bibtex](http://specs.fe.up.pt/tools/clava/clava_softwarex2020.bib)]

# Acknowledgments

This work has been partially funded by the [ANTAREX project](http://antarex-project.eu) through the EU H2020 FET-HPC program under grant no. 671623. João Bispo acknowledges the support provided by Fundação para a Ciência e a Tecnologia, Portugal, under Post-Doctoral grant SFRH/BPD/118211/2016.

# Contacts

[João Bispo](mailto:jbispo@fe.up.pt)


# Google Google Cloud Spanner JDBC Client for Java

Java idiomatic client for [Google Cloud Spanner JDBC][product-docs].

[![Maven][maven-version-image]][maven-version-link]
![Stability][stability-image]

- [Product Documentation][product-docs]
- [Client Library Documentation][javadocs]

## Quickstart

If you are using Maven, add this to your pom.xml file:

```xml
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-spanner-jdbc</artifactId>
  <version>2.4.1</version>
</dependency>
```

If you are using Gradle without BOM, add this to your dependencies

```Groovy
implementation 'com.google.cloud:google-cloud-spanner-jdbc:2.4.1'
```

If you are using SBT, add this to your dependencies

```Scala
libraryDependencies += "com.google.cloud" % "google-cloud-spanner-jdbc" % "2.4.1"
```

## Authentication

See the [Authentication][authentication] section in the base directory's README.

## Authorization

The client application making API calls must be granted [authorization scopes][auth-scopes] required for the desired Google Cloud Spanner JDBC APIs, and the authenticated principal must have the [IAM role(s)][predefined-iam-roles] required to access GCP resources using the Google Cloud Spanner JDBC API calls.

## Getting Started

### Prerequisites

You will need a [Google Cloud Platform Console][developer-console] project with the Google Cloud Spanner JDBC [API enabled][enable-api].

[Follow these instructions][create-project] to get your project set up. You will also need to set up the local development environment by
[installing the Google Cloud SDK][cloud-sdk] and running the following commands in command line:
`gcloud auth login` and `gcloud config set project [YOUR PROJECT ID]`.

### Installation and setup

You'll need to obtain the `google-cloud-spanner-jdbc` library.  See the [Quickstart](#quickstart) section
to add `google-cloud-spanner-jdbc` as a dependency in your code.

## About Google Cloud Spanner JDBC

[Google Cloud Spanner JDBC][product-docs]

See the [Google Cloud Spanner JDBC client library docs][javadocs] to learn how to
use this Google Cloud Spanner JDBC Client Library.

### Creating a JDBC Connection

The following example shows how to create a JDBC connection to Cloud Spanner and execute a simple query.

```java
String projectId = "my-project";
String instanceId = "my-instance";
String databaseId = "my-database";

try (Connection connection =
    DriverManager.getConnection(
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s",
            projectId, instanceId, databaseId))) {
  try (Statement statement = connection.createStatement()) {
    try (ResultSet rs = statement.executeQuery("SELECT CURRENT_TIMESTAMP()")) {
      while (rs.next()) {
        System.out.printf(
            "Connected to Cloud Spanner at [%s]%n", rs.getTimestamp(1).toString());
      }
    }
  }
}
```

### Connection URL Properties

The Cloud Spanner JDBC driver supports the following connection URL properties. Note that all of
these can also be supplied in a Properties instance that is passed to the
`DriverManager#getConnection(String url, Properties properties)` method.

#### Commonly Used Properties
- credentials (String): URL for the credentials file to use for the connection. If you do not specify any credentials at all, the default credentials of the environment as returned by `GoogleCredentials#getApplicationDefault()` is used. Example: `jdbc:cloudspanner:/projects/my-project/instances/my-instance/databases/my-db;credentials=/path/to/credentials.json`
- autocommit (boolean): Sets the initial autocommit mode for the connection. Default is true.
- readonly (boolean): Sets the initial readonly mode for the connection. Default is false.
- autoConfigEmulator (boolean): Automatically configure the connection to try to connect to the Cloud Spanner emulator. You do not need to specify any host or port in the connection string as long as the emulator is running on the default host/port (localhost:9010). The instance and database in the connection string will automatically be created if these do not yet exist on the emulator. This means that you do not need to execute any `gcloud` commands on the emulator to create the instance and database before you can connect to it. Example: `jdbc:cloudspanner:/projects/test-project/instances/test-instance/databases/test-db;autoConfigEmulator=true`
- usePlainText (boolean): Sets whether the JDBC connection should establish an unencrypted connection to a (local) server. This option can only be used when connecting to a local emulator that does not require an encrypted connection, and that does not require authentication. Example: `jdbc:cloudspanner://localhost:9010/projects/test-project/instances/test-instance/databases/test-db;usePlainText=true`
- optimizerVersion (String): Sets the default query optimizer version to use for this connection. See also https://cloud.google.com/spanner/docs/query-optimizer/query-optimizer-versions.

#### Advanced Properties
- minSessions (int): Sets the minimum number of sessions in the backing session pool. Defaults to 100.
- maxSessions (int): Sets the maximum number of sessions in the backing session pool. Defaults to 400.
- numChannels (int): Sets the number of gRPC channels to use. Defaults to 4.
- retryAbortsInternally (boolean): The JDBC driver will by default automatically retry aborted transactions internally. This is done by keeping track of all statements and the results of these during a transaction, and if the transaction is aborted by Cloud Spanner, it will replay the statements on a new transaction and compare the results with the initial attempt. Disable this option if you want to handle aborted transactions in your own application.
- oauthToken (string): A valid pre-existing OAuth token to use for authentication for this connection. Setting this property will take precedence over any value set for a credentials file.
- lenient (boolean): Enable this to force the JDBC driver to ignore unknown properties in the connection URL. Some applications automatically add additional properties to the URL that are not recognized by the JDBC driver. Normally, the JDBC driver will reject this, unless `lenient` mode is enabled.

### Jar with Dependencies
A single jar with all dependencies can be downloaded from https://repo1.maven.org/maven2/com/google/cloud/google-cloud-spanner-jdbc/latest
or be built with the command `mvn package` (select the jar that is named `google-cloud-spanner-jdbc-<version>-single-jar-with-dependencies.jar`).

### Creating a Shaded Jar

A jar with all dependencies included is automatically generated when you execute `mvn package`.
The dependencies in this jar are not shaded. To create a jar with shaded dependencies you must
activate the `shade` profile like this:

 ```
 mvn package -Pshade
 ```

## Troubleshooting

To get help, follow the instructions in the [shared Troubleshooting document][troubleshooting].

## Supported Java Versions

Java 8 or above is required for using this client.

Google's Java client libraries,
[Google Cloud Client Libraries][cloudlibs]
and
[Google Cloud API Libraries][apilibs],
follow the
[Oracle Java SE support roadmap][oracle]
(see the Oracle Java SE Product Releases section).

### For new development

In general, new feature development occurs with support for the lowest Java
LTS version covered by  Oracle's Premier Support (which typically lasts 5 years
from initial General Availability). If the minimum required JVM for a given
library is changed, it is accompanied by a [semver][semver] major release.

Java 11 and (in September 2021) Java 17 are the best choices for new
development.

### Keeping production systems current

Google tests its client libraries with all current LTS versions covered by
Oracle's Extended Support (which typically lasts 8 years from initial
General Availability).

#### Legacy support

Google's client libraries support legacy versions of Java runtimes with long
term stable libraries that don't receive feature updates on a best efforts basis
as it may not be possible to backport all patches.

Google provides updates on a best efforts basis to apps that continue to use
Java 7, though apps might need to upgrade to current versions of the library
that supports their JVM.

#### Where to find specific information

The latest versions and the supported Java versions are identified on
the individual GitHub repository `github.com/GoogleAPIs/java-SERVICENAME`
and on [google-cloud-java][g-c-j].

## Versioning

This library follows [Semantic Versioning](http://semver.org/).

## Contributing

Contributions to this library are always welcome and highly encouraged.

See [CONTRIBUTING][contributing] for more information how to get started.

Please note that this project is released with a Contributor Code of Conduct. By participating in
this project you agree to abide by its terms. See [Code of Conduct][code-of-conduct] for more
information.

## License

Apache 2.0 - See [LICENSE][license] for more information.

## CI Status

Java Version | Status
------------ | ------
Java 8 | [![Kokoro CI][kokoro-badge-image-2]][kokoro-badge-link-2]
Java 8 OSX | [![Kokoro CI][kokoro-badge-image-3]][kokoro-badge-link-3]
Java 8 Windows | [![Kokoro CI][kokoro-badge-image-4]][kokoro-badge-link-4]
Java 11 | [![Kokoro CI][kokoro-badge-image-5]][kokoro-badge-link-5]

Java is a registered trademark of Oracle and/or its affiliates.

[product-docs]: https://cloud.google.com/spanner/docs/use-oss-jdbc
[javadocs]: https://googleapis.dev/java/google-cloud-spanner-jdbc/latest/index.html
[kokoro-badge-image-1]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java7.svg
[kokoro-badge-link-1]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java7.html
[kokoro-badge-image-2]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java8.svg
[kokoro-badge-link-2]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java8.html
[kokoro-badge-image-3]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java8-osx.svg
[kokoro-badge-link-3]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java8-osx.html
[kokoro-badge-image-4]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java8-win.svg
[kokoro-badge-link-4]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java8-win.html
[kokoro-badge-image-5]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java11.svg
[kokoro-badge-link-5]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-spanner-jdbc/java11.html
[stability-image]: https://img.shields.io/badge/stability-ga-green
[maven-version-image]: https://img.shields.io/maven-central/v/com.google.cloud/google-cloud-spanner-jdbc.svg
[maven-version-link]: https://search.maven.org/search?q=g:com.google.cloud%20AND%20a:google-cloud-spanner-jdbc&core=gav
[authentication]: https://github.com/googleapis/google-cloud-java#authentication
[auth-scopes]: https://developers.google.com/identity/protocols/oauth2/scopes
[predefined-iam-roles]: https://cloud.google.com/iam/docs/understanding-roles#predefined_roles
[iam-policy]: https://cloud.google.com/iam/docs/overview#cloud-iam-policy
[developer-console]: https://console.developers.google.com/
[create-project]: https://cloud.google.com/resource-manager/docs/creating-managing-projects
[cloud-sdk]: https://cloud.google.com/sdk/
[troubleshooting]: https://github.com/googleapis/google-cloud-common/blob/main/troubleshooting/readme.md#troubleshooting
[contributing]: https://github.com/googleapis/java-spanner-jdbc/blob/main/CONTRIBUTING.md
[code-of-conduct]: https://github.com/googleapis/java-spanner-jdbc/blob/main/CODE_OF_CONDUCT.md#contributor-code-of-conduct
[license]: https://github.com/googleapis/java-spanner-jdbc/blob/main/LICENSE

[libraries-bom]: https://github.com/GoogleCloudPlatform/cloud-opensource-java/wiki/The-Google-Cloud-Platform-Libraries-BOM
[shell_img]: https://gstatic.com/cloudssh/images/open-btn.png

[semver]: https://semver.org/
[cloudlibs]: https://cloud.google.com/apis/docs/client-libraries-explained
[apilibs]: https://cloud.google.com/apis/docs/client-libraries-explained#google_api_client_libraries
[oracle]: https://www.oracle.com/java/technologies/java-se-support-roadmap.html
[g-c-j]: http://github.com/googleapis/google-cloud-java


# Temporal Java SDK  [![Build status](https://github.com/temporalio/sdk-java/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/temporalio/sdk-java/actions/workflows/ci.yml) [![Coverage Status](https://coveralls.io/repos/github/temporalio/sdk-java/badge.svg?branch=master)](https://coveralls.io/github/temporalio/sdk-java?branch=master)

[Temporal](https://github.com/temporalio/temporal) is a Workflow-as-Code platform for building and operating
resilient applications using developer-friendly primitives, instead of constantly fighting your infrastructure.

The Java SDK is the framework for authoring Workflows and Activities in Java. (For other languages, see [Temporal SDKs](https://docs.temporal.io/application-development).)

Java SDK:

- [Java SDK documentation](https://docs.temporal.io/docs/java/introduction)
- [Javadoc API reference](https://www.javadoc.io/doc/io.temporal/temporal-sdk/latest/index.html)
- [Sample applications](https://github.com/temporalio/samples-java#samples-directory)

Temporal:

- [Temporal docs](https://docs.temporal.io/)
- [Install Temporal Server](https://docs.temporal.io/docs/server/quick-install)
- [Temporal CLI](https://docs.temporal.io/docs/devtools/tctl/)

## Supported Java runtimes

- Java 1.8+
- [GraalVM native-image](docs/AOT-native-image.md)

## Build configuration

[Find the latest release](https://search.maven.org/artifact/io.temporal/temporal-sdk) of the Temporal Java SDK at maven central.

Add *temporal-sdk* as a dependency to your *pom.xml*:

    <dependency>
      <groupId>io.temporal</groupId>
      <artifactId>temporal-sdk</artifactId>
      <version>N.N.N</version>
    </dependency>

or to *build.gradle*:

    compile group: 'io.temporal', name: 'temporal-sdk', version: 'N.N.N'

## Contributing

We'd love your help in improving the Temporal Java SDK. Please review our [contribution guidelines](CONTRIBUTING.md).

## Snapshot release

We also publish snapshot releases during SDK development often under the version `1.x.0-SNAPSHOT`. This allows users to test out new SDK features before an official SDK release.

[Snapshot releases](https://oss.sonatype.org/content/repositories/snapshots/io/temporal/temporal-sdk/) Find the latest snapsphot release.

To add Sonatype snapshot repository to your *pom.xml*:

    <repositories>
        <repository>
            <id>oss-sonatype</id>
            <name>oss-sonatype</name>
            <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>

Or to *build.gradle*:

    repositories {
        maven {
            url "https://oss.sonatype.org/content/repositories/snapshots/"
        }
      ...
    }

Note: Snapshot releases are not official release and normal backwards compatibility, stability or support
does not apply

## License

Copyright (C) 2022 Temporal Technologies, Inc. All Rights Reserved.

Copyright (C) 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.

Modifications copyright (C) 2017 Uber Technologies, Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this material except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


# Google Cloud Logging Logback Appender Client for Java

Java idiomatic client for [Cloud Logging Logback Appender][product-docs].

[![Maven][maven-version-image]][maven-version-link]
![Stability][stability-image]

- [Product Documentation][product-docs]
- [Client Library Documentation][javadocs]

> Note: This client is a work-in-progress, and may occasionally
> make backwards-incompatible changes.

## Quickstart

If you are using Maven, add this to your pom.xml file:

<!-- {x-version-update-start:google-cloud-logging-logback:released} -->

```xml
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-logging-logback</artifactId>
  <version>0.131.7-alpha</version>
</dependency>
```

If you are using Gradle without BOM, add this to your dependencies:

```Groovy
implementation 'com.google.cloud:google-cloud-logging-logback:0.131.7-alpha'
```

If you are using SBT, add this to your dependencies:

```Scala
libraryDependencies += "com.google.cloud" % "google-cloud-logging-logback" % "0.131.7-alpha"
```
<!-- {x-version-update-end} -->

## Authentication

See the [Authentication][authentication] section in the base directory's README.

## Authorization

The client application making API calls must be granted [authorization scopes][auth-scopes] required for the desired Cloud Logging Logback Appender APIs, and the authenticated principal must have the [IAM role(s)][predefined-iam-roles] required to access GCP resources using the Cloud Logging Logback Appender API calls.

## Getting Started

### Prerequisites

You will need a [Google Cloud Platform Console][developer-console] project with the Cloud Logging Logback Appender [API enabled][enable-api].

[Follow these instructions][create-project] to get your project set up. You will also need to set up the local development environment by
[installing the Google Cloud Command Line Interface][cloud-cli] and running the following commands in command line:
`gcloud auth login` and `gcloud config set project [YOUR PROJECT ID]`.

### Installation and setup

You'll need to obtain the `google-cloud-logging-logback` library.  See the [Quickstart](#quickstart) section
to add `google-cloud-logging-logback` as a dependency in your code.

## About Cloud Logging Logback Appender

[Cloud Logging Logback Appender][product-docs]

See the [Cloud Logging Logback Appender client library docs][javadocs] to learn how to
use this Cloud Logging Logback Appender Client Library.

### Usage
Add the appender to your [Logback configuration](https://logback.qos.ch/manual/configuration.html) `logback.xml`.
See [Logback filters](https://logback.qos.ch/manual/filters.html#thresholdFilter) for information on filtering log output and
 [encoders](https://logback.qos.ch/manual/encoders.html) for information on formatting.

```xml
<configuration>
  <appender name="CLOUD" class="com.google.cloud.logging.logback.LoggingAppender">
    <!-- Optional: filter logs at and above this level -->
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
        <level>INFO</level>
    </filter>

    <!-- Optional: defaults to "java.log" -->
    <log>application.log</log>

    <!-- Optional: defaults to "ERROR" -->
    <flushLevel>WARN</flushLevel>

    <!-- Optional: defaults to ASYNC -->
    <writeSynchronicity>SYNC</writeSynchronicity>

    <!-- Optional: defaults to true -->
    <autoPopulateMetadata>false</autoPopulateMetadata>

    <!-- Optional: defaults to false -->
    <redirectToStdout>true</redirectToStdout>

    <!-- Optional: auto detects on App Engine Flex, Standard, GCE and GKE, defaults to "global". -->
    <resourceType></resourceType>

    <!-- Optional: defaults to the default credentials of the environment -->
    <credentialsFile>/path/to/credentials/file</credentialsFile>

    <!-- Optional: defaults to the project id obtained during authentication process. Project id is also used to construct resource name of the log entries -->
    <logDestinationProjectId>String</logDestinationProjectId>

    <!-- Optional: add custom labels to log entries using LoggingEnhancer classes -->
    <enhancer>com.example.enhancers.TestLoggingEnhancer</enhancer>
    <enhancer>com.example.enhancers.AnotherEnhancer</enhancer>

    <!-- Optional: specifies if a batch's valid entries should be written even if some other entry failed due to an error. Defaults to true
    See [partial_success](https://cloud.google.com/logging/docs/reference/v2/rest/v2/entries/write#body.request_body.FIELDS.partial_success) for more info -->
    <partialSuccess>true</partialSuccess>

    <!-- Optional: In the asynchronous mode the call(s) to Logging API takes place asynchronously and few calls to `write()`
    method may be batched together to compose a single call to Logging API. In order to control the batching settings,
    the `logbackBatchingSettings` section can be used as shown below.
    See [BatchingSettings](https://cloud.google.com/java/docs/reference/gax/latest/com.google.api.gax.batching.BatchingSettings)
    for more info regarding parameters shown below -->
    <logbackBatchingSettings>
      <elementCountThreshold>100</elementCountThreshold>
      <requestByteThreshold>1000</requestByteThreshold>
      <delayThreshold>500</delayThreshold>
      <maxOutstandingElementCount>10000</maxOutstandingElementCount>
      <maxOutstandingRequestBytes>100000</maxOutstandingRequestBytes>
      <limitExceededBehavior>Ignore</limitExceededBehavior>
    </logbackBatchingSettings>
  </appender>

  <root level="info">
    <appender-ref ref="CLOUD" />
  </root>
</configuration>
```

In your code:

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TestLogger {
    private final Logger logger = LoggerFactory.getLogger(TestLogger.class);

    public void log(String name) {
        logger.info("This is a test");
    }

    public static void main(String[] args) {
        TestLogger testLogger = new TestLogger();
        testLogger.log("test");
    }
}
```

### Populate log entries with metadata

The library provides multiple ways to enrich log entries with additional information.
You can select one or more ways to customize log entries that will be written into Cloud Logging.

* Manually update a log entry using [`LoggingEnhancer`]
(https://github.com/googleapis/java-logging/blob/main/google-cloud-logging/src/main/java/com/google/cloud/logging/.
* Use [`ILoggingEvent`](https://logback.qos.ch/apidocs/ch/qos/logback/classic/spi/ILoggingEvent.html) to update a log entry with [`LoggingEventEnhancer`]
(https://github.com/googleapis/java-logging-logback/blob/main/src/main/java/com/google/cloud/logging/logback/LoggingEventEnhancer.java).
* Enable [auto-population](https://github.com/googleapis/java-logging#auto-population-of-log-entrys-metadata) of the `LogEntry` metadata using the `autoPopulateMetadata` configuration flag.

#### Optimize log ingestion

By default, the appender will ingest log entries asynchronously by calling Logging API.
Multiple calls may be aggregated before being sent to improve use of API quota and bandwidth.
You can set the `writeSynchronicity` configuration flag to `SYNC` if they want to ingest log entries synchronously.
Note that configuring synchronous ingestion will probably result in performance penalties to your applications.
If you plan to deploy your application in one of Google Cloud managed environments (e.g. Cloud Run, Cloud Function or App Engine),
you can leverage the support provided by the implicit logging agent and the [structured logging](https://cloud.google.com/logging/docs/structured-logging) feature.
To use it, set the `redirectToStdout` configuration flag to `true`.
This flag instructs the appender to print the log entries to `stdout` instead of ingesting them using Logging API.
The log entries are printed using the [structured logging Json format](https://cloud.google.com/logging/docs/structured-logging#special-payload-fields).
In result, the logging agent will be responsible for ingesting the logs to Logging API.
Note that using the structured logging Json format you cannot control the log name where the logs will be ingested.
The logs will be ingested into the project that hosts the environment where your application is running.
The configuration `logDestinationProjectId` will be ignored.

## Samples

Samples are in the [`samples/`](https://github.com/googleapis/java-logging-logback/tree/main/samples) directory.

| Sample                      | Source Code                       | Try it |
| --------------------------- | --------------------------------- | ------ |
| Quickstart | [source code](https://github.com/googleapis/java-logging-logback/blob/main/samples/snippets/src/main/java/com/example/logging/logback/Quickstart.java) | [![Open in Cloud Shell][shell_img]](https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/googleapis/java-logging-logback&page=editor&open_in_editor=samples/snippets/src/main/java/com/example/logging/logback/Quickstart.java) |
| Example Enhancer | [source code](https://github.com/googleapis/java-logging-logback/blob/main/samples/snippets/src/main/java/com/example/logging/logback/enhancers/ExampleEnhancer.java) | [![Open in Cloud Shell][shell_img]](https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/googleapis/java-logging-logback&page=editor&open_in_editor=samples/snippets/src/main/java/com/example/logging/logback/enhancers/ExampleEnhancer.java) |

## Troubleshooting

To get help, follow the instructions in the [shared Troubleshooting document][troubleshooting].

## Supported Java Versions

Java 8 or above is required for using this client.

Google's Java client libraries,
[Google Cloud Client Libraries][cloudlibs]
and
[Google Cloud API Libraries][apilibs],
follow the
[Oracle Java SE support roadmap][oracle]
(see the Oracle Java SE Product Releases section).

### For new development

In general, new feature development occurs with support for the lowest Java
LTS version covered by  Oracle's Premier Support (which typically lasts 5 years
from initial General Availability). If the minimum required JVM for a given
library is changed, it is accompanied by a [semver][semver] major release.

Java 11 and (in September 2021) Java 17 are the best choices for new
development.

### Keeping production systems current

Google tests its client libraries with all current LTS versions covered by
Oracle's Extended Support (which typically lasts 8 years from initial
General Availability).

#### Legacy support

Google's client libraries support legacy versions of Java runtimes with long
term stable libraries that don't receive feature updates on a best efforts basis
as it may not be possible to backport all patches.

Google provides updates on a best efforts basis to apps that continue to use
Java 7, though apps might need to upgrade to current versions of the library
that supports their JVM.

#### Where to find specific information

The latest versions and the supported Java versions are identified on
the individual GitHub repository `github.com/GoogleAPIs/java-SERVICENAME`
and on [google-cloud-java][g-c-j].

## Versioning

This library follows [Semantic Versioning](http://semver.org/).

It is currently in major version zero (``0.y.z``), which means that anything may change at any time
and the public API should not be considered stable.

## Contributing

Contributions to this library are always welcome and highly encouraged.

See [CONTRIBUTING][contributing] for more information how to get started.

Please note that this project is released with a Contributor Code of Conduct. By participating in
this project you agree to abide by its terms. See [Code of Conduct][code-of-conduct] for more
information.

## License

Apache 2.0 - See [LICENSE][license] for more information.

## CI Status

Java Version | Status
------------ | ------
Java 8 | [![Kokoro CI][kokoro-badge-image-2]][kokoro-badge-link-2]
Java 8 OSX | [![Kokoro CI][kokoro-badge-image-3]][kokoro-badge-link-3]
Java 8 Windows | [![Kokoro CI][kokoro-badge-image-4]][kokoro-badge-link-4]
Java 11 | [![Kokoro CI][kokoro-badge-image-5]][kokoro-badge-link-5]

Java is a registered trademark of Oracle and/or its affiliates.

[product-docs]: https://cloud.google.com/logging/docs/setup/java#logback_appender_for
[javadocs]: https://cloud.google.com/java/docs/reference/google-cloud-logging-logback/latest/history
[kokoro-badge-image-1]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java7.svg
[kokoro-badge-link-1]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java7.html
[kokoro-badge-image-2]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java8.svg
[kokoro-badge-link-2]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java8.html
[kokoro-badge-image-3]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java8-osx.svg
[kokoro-badge-link-3]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java8-osx.html
[kokoro-badge-image-4]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java8-win.svg
[kokoro-badge-link-4]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java8-win.html
[kokoro-badge-image-5]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java11.svg
[kokoro-badge-link-5]: http://storage.googleapis.com/cloud-devrel-public/java/badges/java-logging-logback/java11.html
[stability-image]: https://img.shields.io/badge/stability-preview-yellow
[maven-version-image]: https://img.shields.io/maven-central/v/com.google.cloud/google-cloud-logging-logback.svg
[maven-version-link]: https://central.sonatype.com/artifact/com.google.cloud/google-cloud-logging-logback/0.131.7-alpha
[authentication]: https://github.com/googleapis/google-cloud-java#authentication
[auth-scopes]: https://developers.google.com/identity/protocols/oauth2/scopes
[predefined-iam-roles]: https://cloud.google.com/iam/docs/understanding-roles#predefined_roles
[iam-policy]: https://cloud.google.com/iam/docs/overview#cloud-iam-policy
[developer-console]: https://console.developers.google.com/
[create-project]: https://cloud.google.com/resource-manager/docs/creating-managing-projects
[cloud-cli]: https://cloud.google.com/cli
[troubleshooting]: https://github.com/googleapis/google-cloud-java/blob/main/TROUBLESHOOTING.md
[contributing]: https://github.com/googleapis/java-logging-logback/blob/main/CONTRIBUTING.md
[code-of-conduct]: https://github.com/googleapis/java-logging-logback/blob/main/CODE_OF_CONDUCT.md#contributor-code-of-conduct
[license]: https://github.com/googleapis/java-logging-logback/blob/main/LICENSE

[enable-api]: https://console.cloud.google.com/flows/enableapi?apiid=logging.googleapis.com
[libraries-bom]: https://github.com/GoogleCloudPlatform/cloud-opensource-java/wiki/The-Google-Cloud-Platform-Libraries-BOM
[shell_img]: https://gstatic.com/cloudssh/images/open-btn.png

[semver]: https://semver.org/
[cloudlibs]: https://cloud.google.com/apis/docs/client-libraries-explained
[apilibs]: https://cloud.google.com/apis/docs/client-libraries-explained#google_api_client_libraries
[oracle]: https://www.oracle.com/java/technologies/java-se-support-roadmap.html
[g-c-j]: http://github.com/googleapis/google-cloud-java