opentelemetry-java

Instrument Java applications with OpenTelemetry for traces, metrics, and context propagation.

Updated Jan 28, 2026
One-click install
npx skills add https://github.com/cedricziel/claude-otel-plugin --skill opentelemetry-java
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: opentelemetry-java
Source: https://github.com/cedricziel/claude-otel-plugin/tree/main/.claude/skills/opentelemetry-java
Command: npx skills add https://github.com/cedricziel/claude-otel-plugin --skill opentelemetry-java

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides expert guidance for instrumenting Java applications with OpenTelemetry, enabling both automatic and manual instrumentation, Spring Boot integration, and best practices to enhance observability.

Core Features & Use Cases

  • Automatic instrumentation with the OpenTelemetry Java agent
  • Manual instrumentation using the OpenTelemetry API
  • Spring Boot and framework integration guidance
  • Metrics, traces, and context propagation patterns
  • Troubleshooting and production-readiness best practices

Quick Start

Guide the user through setting up the Java agent, configuring OTLP exporters, and instrumenting a sample Spring Boot application.

Frequently Asked Questions about opentelemetry-java

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I instrument a Java application with OpenTelemetry?

Instrument Java applications with OpenTelemetry using the Java agent for automatic instrumentation or the OpenTelemetry API for manual instrumentation. The agent requires minimal setup—download it, add it to your JVM startup flags, and configure OTLP exporters to send traces, metrics, and context to your backend.

Can I use OpenTelemetry with Spring Boot?

Yes. OpenTelemetry integrates seamlessly with Spring Boot through the Java agent or Spring Boot starter dependencies. The agent automatically instruments Spring components, while manual API usage lets you add custom spans and metrics within your application logic.

What's the difference between automatic and manual instrumentation in OpenTelemetry?

Automatic instrumentation uses the Java agent to capture traces and metrics from libraries and frameworks without code changes. Manual instrumentation uses the OpenTelemetry API to add custom spans, metrics, and context propagation where you need visibility into application-specific logic.

How do I export traces and metrics from my Java app with OpenTelemetry?

Configure OTLP exporters in your Java application to send traces and metrics to a backend. Set exporter endpoints and protocols via environment variables or application properties, then instrument your code. The exporter handles serialization and transport to your observability platform.

Do I need to know Java before using OpenTelemetry instrumentation?

Yes. This requires working knowledge of Java, the Java agent, Spring Boot integration, and API usage patterns. You'll set up classpaths, configure properties, write instrumentation code, and troubleshoot production deployments—all Java-specific tasks.

What are common instrumentation patterns for production readiness?

Production-ready patterns include context propagation across services, sampling strategies to manage data volume, custom span attributes for debugging, metric aggregation, and error handling in instrumentation code. These practices ensure observability scales without overhead.