Here is a guide on how to send Java application logs to Coralogix by using Logback framework. The main focus of this guide is to integrate an OpenTelemetry Java SDK to Logback framework by implementing opentelemetry-logback-appender-1.0.

Package dependencies setup

First step, you need to add these packages to your project:

ch.qos.logback:logback-classic
ch.qos.logback:logback-core
io.opentelemetry:opentelemetry-sdk
io.opentelemetry:opentelemetry-exporter-otlp
io.opentelemetry.instrumentation:opentelemetry-logback-appender-1.0

Here is how your app's Gradle file can look like.

dependencies {
  // Log4j
  implementation("ch.qos.logback:logback-classic:1.5.23")
  implementation("ch.qos.logback:logback-core:2.17.2")

  // OpenTelemetry SDK & OTLP exporter
  implementation("io.opentelemetry:opentelemetry-sdk")
  implementation("io.opentelemetry:opentelemetry-exporter-otlp")

  // OpenTelemetry log4j appender
  implementation("io.opentelemetry.instrumentation:opentelemetry-logback-appender-1.0")
}

Choose the https://ingress. endpoint that corresponds to your Coralogix domain using the domain selector at the top of the page.

Maven:

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <logback.version>1.5.23</logback.version>
        <opentelemetry.version>1.57.0</opentelemetry.version>
    </properties>

    <dependencies>
        <!-- Logback Core and Classic -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>${logback.version}</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.version}</version>
        </dependency>

        <!-- OpenTelemetry SDK & OTLP exporter -->
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-sdk</artifactId>
            <version>${opentelemetry.version}</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-exporter-otlp</artifactId>
            <version>${opentelemetry.version}</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-sdk-logs</artifactId>
            <version>${opentelemetry.version}</version>
        </dependency>

        <!-- OpenTelemetry Logback Appender -->
        <dependency>
            <groupId>io.opentelemetry.instrumentation</groupId>
            <artifactId>opentelemetry-logback-appender-1.0</artifactId>
            <version>2.23.0-alpha</version>
        </dependency>
    </dependencies>

Please make sure to update the packages to the latest version if you'll use this example for testing.

Configure Logback

Here is how you configure Logback appender in logback.xml to send logs to OpenTelemetry endpoint.

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <appender name="OpenTelemetry"
        class="io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender">
        <captureExperimentalAttributes>false</captureExperimentalAttributes>
        <captureCodeAttributes>false</captureCodeAttributes>
        <captureMarkerAttribute>false</captureMarkerAttribute>
        <captureKeyValuePairAttributes>false</captureKeyValuePairAttributes>
        <captureLoggerContext>false</captureLoggerContext>
        <captureMdcAttributes>*</captureMdcAttributes>
    </appender>

    <root level="INFO">
        <appender-ref ref="console"/>
        <appender-ref ref="OpenTelemetry"/>
    </root>
</configuration>

Application implementation

Finally, make the appender aware of your OpenTelemetry SDK instance as early as possible in your application's startup sequence:

import io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender;
import io.opentelemetry.sdk.OpenTelemetrySdk;

public class Application {
    public static void main(String[] args) {
        // Initialize your OpenTelemetry SDK
        OpenTelemetrySdk openTelemetrySdk = initializeOpenTelemetry();

        // Install the OpenTelemetry appender
        OpenTelemetryAppender.install(openTelemetrySdk);

        // Your application code
        // ...
    }

    private static OpenTelemetrySdk initializeOpenTelemetry() {
        // Your OpenTelemetry SDK initialization code
        // ...
    }
}

Then, in your application code you can use Logback’s Mapped Diagnostic Context (MDC) to create loggers and create log messages. The following an example of creating a logger and logging a message.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

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

    public void processRequest(String requestId, String userId) {
        try {
            MDC.put("requestId", requestId);
            MDC.put("userId", userId);

            logger.info("Processing request");

            // Your business logic
            // ...

            logger.info("Request processed successfully");
        } finally {
            MDC.clear(); // Always clear MDC to prevent memory leaks
        }
    }
}

Logging output

With OpenTelemetry SDK, we can send logs from the application either to local OpenTelemetry Collector setup or directly to Coralogix, using an OpenTelemetry endpoint.

OpenTelemetry Collector

Once we configure the environment variable OTEL_EXPORTER_OTLP_ENDPOINT, setting it to the OpenTelemetry collector's endpoint, we should be able to see application logs coming to the target collector, from where we can also send logs to Coralogix.

Coralogix OpenTelemetry endpoint

Once we configure the environment variables, setting it to the Coralogix OpenTelemetry endpoint with authentication header, application and subsystem name, we should be able to see application logs coming to Coralogix.

For setting up authentication, make sure to use the Send-Your-Data API key.

OTEL_EXPORTER_OTLP_ENDPOINT=https://ingress.:443
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer send_your_data_key" \
OTEL_RESOURCE_ATTRIBUTES="cx.application.name=AppName, cx.subsystem.name=SubName"

Additional resources


Coralogix Endpoints	Coralogix Endpoints

Support

Need help? We love to assist our customers, simply reach out via our in-app chat, and we will walk you through, step by step.

Previous Log4j

Next Java