How to Integrate Java with Logit.io

Java vs Python

As stated Java is one of the most widely used programming languages and commonly developers decide between opting for Java or Python to build their applications. Both of these programming languages are popular and renowned in their domain for the numerous advantages they provide. However, there are some differences between the two tools that lead one tool to be better adapted for a specific use case.

Similarities

• High-Level Languages: Java and Python are high-level, which means they are easy to read, write, and understand. Therefore, they are accessible to beginners but powerful enough for advanced developers.
• Object-Orientated Programming: Both languages support object-oriented principles of inheritance, polymorphism, encapsulation, and abstraction. They allow developers to model the real world through classes and objects, promoting code reusability and modularity.
• Cross-Platform Compatibility: Java and Python are cross-operating system languages, meaning they can compile code written in either language on different operating systems, just with minor adjustments. This is possible for Java because of the JVM, whereas Python is due to the interpreter made for different platforms.
• Strong Community Support: Large and active communities exist for Java and Python developers. This includes extensive library support, frameworks, and a lot of documentation, tutorials, and forums.

Differences

• Syntax and Readability: Python is renowned for its simple, clean, and easy-to-read syntax. It uses indentation to define code blocks, enhancing code readability and lessening the likelihood of errors. Whereas Java has a more verbose syntax that uses braces ‘{}’ to define code blocks and requires explicit declaration of variables and types. This verbosity can make Java code longer and more complex compared to Python’s clean and simple code.
• Performance: As a whole Java is faster in execution when compared to Python. This is due to it being a statically typed, compiled language. Java code is compiled into bytecode, which runs on the JVM, providing increased performance for CPU-intensive tasks.
• Typing System: Python utilizes dynamic typing, so variable types are determined at runtime. This makes Python more flexible but can also lead to runtime errors if not handled carefully. In contrast, Java uses static typing, requiring variable types to be explicitly declared. This can prevent type-related errors at compile time and enhance code safety and predictability.
• Use Cases: Python is highly favored for data science, machine learning, artificial intelligence, scripting, and rapid application development due to its simplicity and the availability of scientific libraries like NumPy, Pandas, and TensorFlow. Java, due to its robustness, scalability, and strong performance, is consistently chosen for large-scale enterprise applications, Android app development, web applications, and server-side technologies.

How to Use OpenTelemetry to Ship Java Traces to Logit.io

For a complete integration guide on using OpenTelemetry to send Java traces to Logit.io, please refer to our documentation. The guide provides step-by-step instructions to help you start monitoring Java traces in Logit.io and leverage various open-source tools as hosted solutions for efficient analysis. Below, we have listed the simple steps that enable you to integrate Java with Logit.io.

1. Install

Open the command prompt or terminal and navigate to where you want your project to live, then paste in the following command:

mvn archetype:generate -DgroupId=logit.apm.testapp -DartifactId=java-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

You will see that a folder has been created called 'logit-apm-test-app', navigate into this folder and you will see a file called pom.xml.

Open this file using your preferred text editor, then copy and paste the code below into the file and save the changes:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  	 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>logit.apm.testapp</groupId>
  <artifactId>java-project</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>java-project</name>
  <url>http://maven.apache.org</url>

  <properties>
      <!-- https://maven.apache.org/general.html#encoding-warning -->
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
      </dependency>
      <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-api</artifactId>
        <version>1.30.1</version>
      </dependency>
      <dependency>
          <groupId>io.opentelemetry</groupId>
          <artifactId>opentelemetry-sdk</artifactId>
          <version>1.30.1</version>
      </dependency>
      <dependency>
          <groupId>io.opentelemetry</groupId>
          <artifactId>opentelemetry-exporter-otlp</artifactId>
          <version>1.30.1</version>
      </dependency>
  	    <dependency>
        <groupId>io.opentelemetry</groupId>
        <artifactId>opentelemetry-exporter-jaeger</artifactId>
        <version>1.10.0</version>
      </dependency>
  </dependencies>
    <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.2.0</version>
        <executions>
            <!-- Attach the shade goal into the package phase -->
          <execution>
              <phase>package</phase>
              <goals>
                  <goal>shade</goal>
              </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-shade-plugin</artifactId>
          <version>3.2.0</version>
          <executions>
          <!-- Attach the shade into the package phase -->
            <execution>
              <phase>package</phase>
              <goals>
                <goal>shade</goal>
              </goals>
              <configuration>
                <transformers>
                  <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                    <mainClass>logit.apm.testapp.App</mainClass>
                  </transformer>
                </transformers>
              </configuration>
            </execution>
          </executions>
      </plugin>
    </plugins>
  </build>
</project>

2. Configuring the App

In the same folder create a new file called config.properties and then open it with your text editor

Paste the following code into the file and then save the changes.

ENDPOINT=https://<your-otel-endpoint-address>
PORT=<your-otel-endpoint-https-port>
USERNAME=<your-otel-username>
PASSWORD=<your-otel-password>

Next, we need to navigate to the following folder:

src -> main -> java -> logit -> -apm -> testapp

Here you will find a file called App.java, this file will contain our app code.

Open the folder using your text editor and paste the following code:

package logit.apm.testapp;

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporter;

import java.util.Base64;
import java.time.Duration;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class App {

    public static void main(String[] args) {

    // Define the service name as a resource attribute
    Resource resource = Resource.create(Attributes.of(AttributeKey.stringKey("service.name"), "LogitJavaTestApp"));

    Properties properties = new Properties();

    try (FileInputStream input = new FileInputStream("./config.properties")) {
            properties.load(input);
        } catch (IOException e) {
            e.printStackTrace();
        }

    String endpoint = properties.getProperty("ENDPOINT");
    String port = properties.getProperty("PORT");
    String username = properties.getProperty("USERNAME");
    String password = properties.getProperty("PASSWORD");
    String encodeBytes = Base64.getEncoder().encodeToString((username + ":" + password).getBytes());

    // Configure the OTLP exporter with basic auth
        OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
                .setEndpoint(endpoint + ":" + port) // Replace with your OTLP endpoint
                .addHeader("Authorization", "Basic " + encodeBytes)
                .build();

        // Set up the SDK tracer provider
        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
        .setResource(resource) 
                .addSpanProcessor(BatchSpanProcessor.builder(spanExporter)
                        .setScheduleDelay(Duration.ofMillis(100))
                        .build())
                .build();

        OpenTelemetrySdk openTelemetrySdk = OpenTelemetrySdk.builder()
                .setTracerProvider(tracerProvider)
                .buildAndRegisterGlobal();

        // Get a tracer
        Tracer tracer = GlobalOpenTelemetry.getTracer("com.example.App");

        // Create a span
        Span span = tracer.spanBuilder("Logit Span Test").startSpan();

    LocalDateTime currentDateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = currentDateTime.format(formatter);

        span.setAttribute("First Message", "This is a test!");
    span.setAttribute("Second Message", "Message sent at " + formattedDateTime);

        span.addEvent("Test Log Event 1");
        span.addEvent("Test Log Event 2");

        span.end();

        // Shut down the SDK
        tracerProvider.close();

        System.out.println("App ran successfully");
    }
}

3. Run the Python App

Navigate back to the logit-apm-test-app folder, the folder that contains your pom.xml file using either the command prompt or terminal window.

Run the following command to build the project.

mvn package

As the project compiles the process and results are written to the command prompt or terminal window.

Still in the logit-apm-test-app folder, using the command prompt or terminal window, run the following command:

java -jar target/java-project-1.0-SNAPSHOT.jar

You will see that a message is returned to say that the app ran successfully.

The action of running the Java app will send traces to your Stack. You can now view these traces in Jaeger.

How to Visualize Java Traces in Logit.io

Viewing your Java traces in Logit.io is possible once you have configured Java to ship traces to Logit.io, which can be achieved by following the steps listed above or by using the instructions in the integration guide. To begin with ‘visualizers’ for Java traces we recommend using Jaeger as this can be launched from the ‘Application Performance Monitoring’ section.

1. Launch APM: From the initial dashboard, scroll down to the Application Performance Monitoring (APM) section, and under ‘Services’ you’ll see Jaeger, select ‘Launch’, or in the top right of your screen select ‘Launch APM’

2. Jaeger: After selecting ‘Launch APM’ or ‘Launch’ you will arrive at the Jaeger UI search page.

3. Visualize Java Data: From this page, you can view all your ingested Java traces, Hosted Jaeger enables you to drill down into specific traces, view service dependencies, analyze latency distributions, and more, making it easier to pinpoint the root causes of performance issues.

If you've enjoyed this article why not read How to Integrate Python with Logit.io or How to Integrate Serilog with Logit.io next?