If you use Java logger with the Cloud Logging Handler, you can configure the handler to output logs to `stdout` using

the [structured logging Json format](https://cloud.google.com/logging/docs/structured-logging#special-payload-fields).

To do this, add `com.google.cloud.logging.LoggingHandler.redirectToStdout=true` to the logger configuration file.

You can use this configuration when running applications in Google Cloud managed environments such as AppEngine, Cloud Run,

Cloud Function or GKE. The logger agent installed on these environments can capture STDOUT and ingest it into Cloud Logging.

The agent can parse structured logs printed to STDOUT and capture additional log metadata beside the log payload.

The parsed information includes severity, source location, user labels, http request and tracing information.

LogEntry object metadata information such as [monitored resource](https://cloud.google.com/logging/docs/reference/v2/rest/v2/MonitoredResource),

[Http request](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#HttpRequest) or

[source location](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogEntrySourceLocation)

are automatically populated with information that the library retrieves from the execution context.

The library populates only empty (set to `null`) LogEntry fields.

This behavior in the `Logging` instance can be opted out via `LoggingOptions`.

Call `LoggingOptions.Builder.setAutoPopulateMetadata(false)` to configure logging options to opt-out the metadata auto-population.

Cloud Logging handler can be configured to opt-out automatic population of the metadata using the logger configuration.

To disable the metadata auto-population add `com.google.cloud.logging.LoggingHandler.autoPopulateMetadata=false`

to the logger configuration file.

The auto-population logic populates source location _only_ for log entries with `Severity.DEBUG` severity.

The execution context of the Http request and tracing information is maintained by `ContextHandler` class.

The context is managed in the scope of the thread.

If you do not use thread pools for multi-threading the `ContextHandler` can be configured to propagate the context

to the scope of the child threads.

To enable this add `com.google.cloud.logging.ContextHandler.useInheritedContext=true` to the logger configuration file.

The library provides two methods to update the context:

* Manually set the context. You can use the following methods of the `Context.Builder` to set the context information.

Use the method `setRequest()` to setup the `HttpRequest` instance or `setRequestUrl()`, `setRequestMethod()`,

`setReferer() `, `setRemoteIp()` and `setServerIp()` to setup the fields of the `HttpRequest`.

The trace and span Ids can be set directly using `setTraceId()` and `setSpanId()` respectively.

Alternatively it can be parsed from the W3C tracing context header using `loadW3CTraceParentContext()` or

from the Google Cloud tracing context header using `loadCloudTraceContext()`.

```java

Context context = Context.newBuilder().setHttpRequest(request).setTrace(traceId).setSpanId(spanId).build();

(new ContextHandler()).setCurrentContext(context);

```

* Using [servlet initializer](https://github.com/googleapis/java-logging-servlet-initializer).

If your application uses a Web server based on Jakarta servlets (e.g. Jetty or Tomcat), you can add the servlet initializer

package to your WAR. The package implements a service provider interface (SPI) for

[javax.servlet.ServletContainerInitializer](https://docs.oracle.com/javaee/6/api/javax/servlet/ServletContainerInitializer.html)

and filters all servlet requests to automatically capture the execution context of the servlet request and store it using

`ContextHandler` class. The stored `Context` class instances are used to populate Http request and tracing information.

If you use Maven, to use the servlet initializer add the following dependency to your BOM:

```xml

<dependency>

<groupId>com.google.cloud</groupId>

<artifactId>google-cloud-logging-servlet-initializer</artifactId>

</dependency>

```

<?xml version="1.0" encoding="UTF-8"?>

<differences>

<difference>

<differenceType>7012</differenceType>

<className>com/google/cloud/logging/Logging</className>

<method>java.lang.Iterable populateMetadata(java.lang.Iterable, com.google.cloud.MonitoredResource, java.lang.String[])</method>

</difference>

</differences>

<dependency>

<groupId>com.google.code.gson</groupId>

<artifactId>gson</artifactId>

<version>2.8.9</version>

</dependency>

this.requestBuilder = request != null ? request.toBuilder() : HttpRequest.newBuilder();

import com.google.cloud.logging.Payload.Type;

import com.google.gson.Gson;

import com.google.gson.GsonBuilder;

import com.google.gson.JsonElement;

import com.google.gson.JsonObject;

import com.google.gson.JsonPrimitive;

import com.google.gson.JsonSerializationContext;

import com.google.gson.JsonSerializer;

private final String trace;

private final String spanId;

private String trace;

private String spanId;

this.trace = trace != null ? trace.toString() : null;

this.spanId = spanId != null ? spanId.toString() : null;

/**

static final class InstantSerializer implements JsonSerializer<Instant> {

@Override

public JsonElement serialize(

Instant src, java.lang.reflect.Type typeOfSrc, JsonSerializationContext context) {

return new JsonPrimitive(src.toString());

}

}

static final class SourceLocationSerializer implements JsonSerializer<SourceLocation> {

@Override

public JsonElement serialize(

SourceLocation src, java.lang.reflect.Type typeOfSrc, JsonSerializationContext context) {

JsonObject obj = new JsonObject();

if (src.getFile() != null) {

obj.addProperty("file", src.getFile());

}

if (src.getLine() != null) {

obj.addProperty("line", src.getLine().toString());

}

if (src.getFunction() != null) {

obj.addProperty("function", src.getFunction());

}

return obj;

}

}

static final class RequestMethodSerializer implements JsonSerializer<HttpRequest.RequestMethod> {

@Override

public JsonElement serialize(

HttpRequest.RequestMethod src,

java.lang.reflect.Type typeOfSrc,

JsonSerializationContext context) {

return new JsonPrimitive(src.name());

}

}

/** Helper class to format one line Json representation of the LogEntry for structured log. */

static final class StructuredLogFormatter {

private final Gson gson;

private final StringBuilder builder;

public StructuredLogFormatter(StringBuilder builder) {

checkNotNull(builder);

this.gson =

new GsonBuilder()

.registerTypeAdapter(Instant.class, new InstantSerializer())

.registerTypeAdapter(SourceLocation.class, new SourceLocationSerializer())

.registerTypeAdapter(HttpRequest.RequestMethod.class, new RequestMethodSerializer())

.create();

this.builder = builder;

}

/**

public StructuredLogFormatter appendField(String name, Object value, boolean appendComma) {

checkNotNull(name);

if (value != null) {

builder.append(gson.toJson(name)).append(":").append(gson.toJson(value));

if (appendComma) {

builder.append(",");

}

}

return this;

}

public StructuredLogFormatter appendField(String name, Object value) {

return appendField(name, value, true);

}

/**

public StructuredLogFormatter appendDict(Map<String, Object> value, boolean appendComma) {

if (value != null) {

String json = gson.toJson(value);

// append json object without brackets

if (json.length() > 1) {

builder.append(json.substring(0, json.length() - 1).substring(1));

if (appendComma) {

builder.append(",");

}

}

}

return this;

}

}

/**

public String toStructuredJsonString() {

if (payload.getType() == Type.PROTO) {

throw new UnsupportedOperationException("LogEntry with protobuf payload cannot be converted");

}

final StringBuilder builder = new StringBuilder("{");

final StructuredLogFormatter formatter = new StructuredLogFormatter(builder);

formatter

.appendField("severity", severity)

.appendField("timestamp", timestamp)

.appendField("httpRequest", httpRequest)

.appendField("logging.googleapis.com/insertId", insertId)

.appendField("logging.googleapis.com/labels", labels)

.appendField("logging.googleapis.com/operation", operation)

.appendField("logging.googleapis.com/sourceLocation", sourceLocation)

.appendField("logging.googleapis.com/spanId", spanId)

.appendField("logging.googleapis.com/trace", trace)

.appendField("logging.googleapis.com/trace_sampled", traceSampled);

if (payload.getType() == Type.STRING) {

formatter.appendField("message", payload.getData(), false);

} else if (payload.getType() == Type.JSON) {

Payload.JsonPayload jsonPayload = (Payload.JsonPayload) payload;

formatter.appendDict(jsonPayload.getDataAsMap(), false);

}

builder.append("}");

return builder.toString();

}