Send Logs Using the OpenTelemetry SDK

1. Install the packages:

   1npm install @opentelemetry/api-logs @opentelemetry/sdk-logs \
   2  @opentelemetry/exporter-logs-otlp-http @opentelemetry/resources \
   3  @opentelemetry/semantic-conventions

2. Create logger.js. The exporter reads the endpoint and headers from the environment variables above.

   1const { LoggerProvider, BatchLogRecordProcessor } = require("@opentelemetry/sdk-logs");
   2const { OTLPLogExporter } = require("@opentelemetry/exporter-logs-otlp-http");
   3const { resourceFromAttributes } = require("@opentelemetry/resources");
   4const { ATTR_SERVICE_NAME } = require("@opentelemetry/semantic-conventions");
   5const { SeverityNumber } = require("@opentelemetry/api-logs");
   6
   7const loggerProvider = new LoggerProvider({
   8  resource: resourceFromAttributes({
   9    [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "my-service",
   10  }),
   11  processors: [new BatchLogRecordProcessor({ exporter: new OTLPLogExporter() })],
   12});
   13
   14const logger = loggerProvider.getLogger("default");
   15
   16process.on("SIGTERM", () => loggerProvider.shutdown());
   17
   18module.exports = { logger, SeverityNumber };

3. Emit logs from your application:

   1const { logger, SeverityNumber } = require("./logger");
   2
   3logger.emit({
   4  severityNumber: SeverityNumber.INFO,
   5  severityText: "INFO",
   6  body: "Hello from Node.js",
   7  attributes: { "user.id": "123" },
   8});

Option A: Java agent (recommended)#

The OpenTelemetry Java agent captures logs from Logback, Log4j 2, and java.util.logging without code changes.

1. Download the agent:

   1wget https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar

2. Set the environment variables and start your application with the agent:

   1java -javaagent:./opentelemetry-javaagent.jar -jar your-app.jar

Option B: Manual SDK setup (Logback)#

1. Add the dependencies (Maven):

   1<dependencyManagement>
   2  <dependencies>
   3    <dependency>
   4      <groupId>io.opentelemetry</groupId>
   5      <artifactId>opentelemetry-bom</artifactId>
   6      <version>1.57.0</version>
   7      <type>pom</type>
   8      <scope>import</scope>
   9    </dependency>
   10    <dependency>
   11      <groupId>io.opentelemetry.instrumentation</groupId>
   12      <artifactId>opentelemetry-instrumentation-bom-alpha</artifactId>
   13      <version>2.23.0-alpha</version>
   14      <type>pom</type>
   15      <scope>import</scope>
   16    </dependency>
   17  </dependencies>
   18</dependencyManagement>
   19
   20<dependencies>
   21  <dependency>
   22    <groupId>io.opentelemetry</groupId>
   23    <artifactId>opentelemetry-sdk</artifactId>
   24  </dependency>
   25  <dependency>
   26    <groupId>io.opentelemetry</groupId>
   27    <artifactId>opentelemetry-sdk-extension-autoconfigure</artifactId>
   28  </dependency>
   29  <dependency>
   30    <groupId>io.opentelemetry</groupId>
   31    <artifactId>opentelemetry-exporter-otlp</artifactId>
   32  </dependency>
   33  <dependency>
   34    <groupId>io.opentelemetry.instrumentation</groupId>
   35    <artifactId>opentelemetry-logback-appender-1.0</artifactId>
   36  </dependency>
   37</dependencies>

2. Add the OpenTelemetry appender to src/main/resources/logback.xml:

   1<configuration>
   2  <appender name="OTEL" class="io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender">
   3    <captureExperimentalAttributes>true</captureExperimentalAttributes>
   4    <captureKeyValuePairAttributes>true</captureKeyValuePairAttributes>
   5  </appender>
   6  <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
   7    <encoder>
   8      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
   9    </encoder>
   10  </appender>
   11  <root level="INFO">
   12    <appender-ref ref="OTEL" />
   13    <appender-ref ref="CONSOLE" />
   14  </root>
   15</configuration>

3. Initialize the SDK and install the appender at startup. The SDK reads the endpoint and headers from the environment variables above.

   1import io.opentelemetry.sdk.OpenTelemetrySdk;
   2import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
   3import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender;
   4import org.slf4j.Logger;
   5import org.slf4j.LoggerFactory;
   6
   7public class Application {
   8    private static final Logger logger = LoggerFactory.getLogger(Application.class);
   9
   10    public static void main(String[] args) {
   11        OpenTelemetrySdk sdk = AutoConfiguredOpenTelemetrySdk.initialize().getOpenTelemetrySdk();
   12        OpenTelemetryAppender.install(sdk);
   13
   14        logger.info("Hello from Java");
   15    }
   16}

OpenTelemetry provides logs SDKs for other languages as well, at different maturity levels. SDKs that follow the OpenTelemetry specification read the environment variables above, so the setup is:

1. Install the OpenTelemetry logs SDK and OTLP log exporter for your language.
2. Create a LoggerProvider with a batch processor and the OTLP log exporter.
3. Connect your logging library through its OpenTelemetry bridge or appender.

See the OpenTelemetry language documentation for language-specific packages and the status of each logs SDK.