Here is a guide on how to send Java application logs to Coralogix by using Log4j framework. The main focus of this guide is to integrate an OpenTelemetry Java SDK to Log4j framework by implementing OpenTelemetryAppender.

Package dependencies setup

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

org.apache.logging.log4j:log4j-api
org.apache.logging.log4j:log4j-core
io.opentelemetry:opentelemetry-sdk
io.opentelemetry:opentelemetry-exporter-otlp
io.opentelemetry.instrumentation:opentelemetry-log4j-appender-2.17

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

dependencies {
  // Log4j
  implementation("org.apache.logging.log4j:log4j-api:2.17.2")
  implementation("org.apache.logging.log4j:log4j-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-log4j-appender-2.17")
}

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>
        <log4j.version>2.25.3</log4j.version>
        <opentelemetry.version>1.57.0</opentelemetry.version>
    </properties>

    <dependencies>
        <!-- Log4j API and Core -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.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>

        <!-- OpenTelemetry Log4j Appender -->
        <dependency>
            <groupId>io.opentelemetry.instrumentation</groupId>
            <artifactId>opentelemetry-log4j-appender-2.17</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 Log4j

Here is how you configure Log4j appender in log4j2.xml to send logs to OpenTelemetry endpoint.

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" packages="io.opentelemetry.instrumentation.log4j.appender.v2_17">

    <Appenders>
        <!-- Console appender for debugging -->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>

        <!-- OpenTelemetry appender -->
        <OpenTelemetry name="OpenTelemetryAppender"/>
    </Appenders>

    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="OpenTelemetryAppender"/>
        </Root>
    </Loggers>
</Configuration>

Application implementation

When configuring the OpenTelemetry SDK during application setup, install the OpenTelemetry log4j log appender.

import io.opentelemetry.instrumentation.log4j.appender.v2_17.OpenTelemetryAppender;
import io.opentelemetry.sdk.OpenTelemetrySdk;

// Setup OpenTelemetry SDK
OpenTelemetrySdk sdk =
    OpenTelemetrySdk.builder()
        .build();

// Install the OpenTelemetry log4j log appender that intercepts log messages and create OTLP logs from them
OpenTelemetryAppender.install(sdk);

Then, in your application code you can use log4j’s LogManager to create loggers and create log messages. The following an example of creating a logger and logging a message.

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

// Use the log4j logger in your application
Logger logger = LogManager.getLogger("my-logger")
Map<String, String> mapMessage = new HashMap<>();
mapMessage.put("app.message", "Something interesting happened");
logger.info(new ObjectMessage(mapMessage));

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

Previous Ruby

Next Logback