opentelemetry-deep-dive

Configure OpenTelemetry instrumentation and Collector pipelines for Java and Python services.

5|1|Updated Jun 17, 2026
One-click install
npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill opentelemetry-deep-dive
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: opentelemetry-deep-dive
Source: https://github.com/roanbrasil/engineer-grade-agent-skills/tree/main/skills/opentelemetry-deep-dive
Command: npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill opentelemetry-deep-dive

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Distributed polyglot services often lack consistent, correlated observability, making it difficult to debug latency issues, trace request flows across services, and monitor system health without excessive telemetry costs or fragile custom instrumentation.

Core Features & Use Cases

  • Cross-Language Instrumentation: Auto and manual setup for Java (including Spring Boot) and Python (including FastAPI) services, with built-in support for context propagation, baggage, and semantic conventions.
  • OTel Collector Pipeline Configuration: Pre-built YAML templates for receivers, processors, and exporters to route traces, metrics, and logs to backends like Jaeger, Prometheus, Tempo, and Grafana Cloud.
  • Sampling Strategy Design: Head and tail sampling configurations to balance telemetry volume and visibility, including error and latency-based sampling to capture critical production issues without overloading backends.
  • Production Guardrails: Checklists and anti-pattern guidance to avoid common pitfalls like span leaks, missing resource attributes, and blocking export processors. Use Case: For a Kafka-based order processing microservices system, use this skill to instrument all Java and Python services, configure tail sampling to capture 100% of failed transactions, and set up a centralized OTel Collector to export telemetry to your existing observability stack.

Quick Start

Use the opentelemetry-deep-dive skill to instrument your Python FastAPI order service with auto-instrumentation and configure the OTel Collector to export traces to Tempo and metrics to Prometheus.

Frequently Asked Questions about opentelemetry-deep-dive

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

FAQPage Schema
How do I set up distributed tracing for Java and Python microservices?

Instrument distributed tracing across Java and Python microservices using OpenTelemetry standards to capture context propagation and semantic conventions. This enables consistent, production-grade observability for tracing request flows across polyglot architectures.

How do I configure an OTel Collector pipeline for traces and metrics?

Configure the OTel Collector pipeline using pre-built YAML templates for receivers, processors, and exporters. This routes traces, metrics, and logs to backends like Jaeger, Prometheus, and Tempo for centralized observability.

What is the best way to reduce telemetry volume without losing critical traces?

Reduce telemetry volume without losing critical traces by implementing head and tail sampling strategies. Tail sampling can capture 100% of failed transactions and latency-based anomalies to prevent backend overload.

Does OpenTelemetry support auto-instrumentation for FastAPI and Spring Boot?

OpenTelemetry supports auto-instrumentation for FastAPI and Spring Boot applications. It provides built-in context propagation and baggage support to correlate traces across polyglot distributed services seamlessly.

Why does my OpenTelemetry setup have missing resource attributes and span leaks?

Missing resource attributes and span leaks occur due to common instrumentation anti-patterns. Production guardrails and checklists help avoid these pitfalls, ensuring non-blocking export processors and proper telemetry context.