Java Instrumentations

dependencies {
    // For LangChain4j
    implementation 'com.arize:openinference-instrumentation-langchain4j:0.1.5'
    
    // For Spring AI
    implementation 'com.arize:openinference-instrumentation-springAI:0.1.0'
    
    // Core packages (usually included as transitive dependencies)
    implementation 'com.arize:openinference-semantic-conventions:0.1.1'
    implementation 'com.arize:openinference-instrumentation:0.1.1'
}

<dependencies>
    <!-- For LangChain4j -->
    <dependency>
        <groupId>com.arize</groupId>
        <artifactId>openinference-instrumentation-langchain4j</artifactId>
        <version>0.1.5</version>
    </dependency>
    
    <!-- For Spring AI -->
    <dependency>
        <groupId>com.arize</groupId>
        <artifactId>openinference-instrumentation-springAI</artifactId>
        <version>0.1.0</version>
    </dependency>
    
    <!-- Core packages (usually included as transitive dependencies) -->
    <dependency>
        <groupId>com.arize</groupId>
        <artifactId>openinference-semantic-conventions</artifactId>
        <version>0.1.1</version>
    </dependency>
    <dependency>
        <groupId>com.arize</groupId>
        <artifactId>openinference-instrumentation</artifactId>
        <version>0.1.1</version>
    </dependency>
</dependencies>

import com.arize.instrumentation.langchain4j.LangChain4jInstrumentor;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class QuickStart {
    public static void main(String[] args) {
        // Initialize OpenTelemetry (see documentation for details)
        initializeOpenTelemetry();
        
        // Enable instrumentation
        LangChain4jInstrumentor.instrument();
        
        // Use LangChain4j normally - traces are captured automatically
        OpenAiChatModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4")
            .build();
        
        String response = model.generate("Hello, world!");
        System.out.println(response);
    }
}

import com.arize.instrumentation.OITracer;
import com.arize.instrumentation.TraceConfig;
import com.arize.instrumentation.springAI.SpringAIInstrumentor;
import io.micrometer.observation.ObservationRegistry;
import org.springframework.ai.openai.OpenAiChatModel;

public class QuickStart {
    public static void main(String[] args) {
        // Initialize OpenTelemetry
        var tracerProvider = initializeOpenTelemetry();
        
        // Create OITracer and register handler
        OITracer tracer = new OITracer(
            tracerProvider.get("my-app"),
            TraceConfig.getDefault()
        );
        
        ObservationRegistry registry = ObservationRegistry.create();
        registry.observationConfig()
            .observationHandler(new SpringAIInstrumentor(tracer));
        
        // Configure chat model with registry
        OpenAiChatModel chatModel = OpenAiChatModel.builder()
            .observationRegistry(registry)
            .build();
        
        // Use Spring AI - traces are captured automatically
        var response = chatModel.call(
            new Prompt("Hello, world!")
        );
    }
}

import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;

public class OpenTelemetryConfig {
    public static SdkTracerProvider initializeOpenTelemetry() {
        Resource resource = Resource.getDefault().merge(
            Resource.create(Attributes.builder()
                .put("service.name", "my-java-app")
                .put("service.version", "1.0.0")
                .build())
        );
        
        OtlpGrpcSpanExporter exporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("http://localhost:4317")
            .build();
        
        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(BatchSpanProcessor.builder(exporter).build())
            .setResource(resource)
            .build();
        
        OpenTelemetrySdk.builder()
            .setTracerProvider(tracerProvider)
            .buildAndRegisterGlobal();
        
        return tracerProvider;
    }
}

import com.arize.instrumentation.TraceConfig;

TraceConfig config = TraceConfig.builder()
    .hideInputMessages(true)   // Don't capture input messages
    .hideOutputMessages(true)  // Don't capture output messages
    .build();

public static void main(String[] args) {
    SdkTracerProvider tracerProvider = initializeOpenTelemetry();
    
    // ... your application code ...
    
    // Flush and shutdown before exit
    tracerProvider.forceFlush()
        .join(10, TimeUnit.SECONDS);
    tracerProvider.shutdown()
        .join(10, TimeUnit.SECONDS);
}

import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.api.common.Attributes;

Resource resource = Resource.getDefault().merge(
    Resource.create(Attributes.builder()
        .put("service.name", "my-app")
        .put("service.version", "1.0.0")
        .put("deployment.environment", "production")
        .put("project.name", "my-ai-project")
        .build())
);

configurations.all {
    resolutionStrategy {
        force 'io.opentelemetry:opentelemetry-api:1.49.0'
        force 'io.opentelemetry:opentelemetry-sdk:1.49.0'
    }
}