Using Sentry SDK with OTLP Integration

Overview

The Sentry SDK’s OTLP integration provides the simplest way to send OpenTelemetry data to Sentry. Unlike the direct SDK approach or collector approach, you don’t need to manually configure OTLP endpoints or authentication headers.

Official Documentation

For complete reference on the OTLP integration, see the Sentry Python SDK documentation.

How the Demo App Uses This

The demo includes a Python Inventory Service that demonstrates the OTLP integration. This service:

• Runs on http://localhost:3003
• Uses Flask with OpenTelemetry auto-instrumentation
• Sends traces directly to Sentry using only the DSN

Key Files

File	Purpose
python-service/src/instrument.py	Sentry OTLP integration setup
python-service/src/app.py	Flask application with auto-instrumentation
python-service/.env	Configuration (just needs SENTRY_DSN)

Running the Python Service

Running Alongside Other Services

The Python service runs on port 3003, separate from the Node.js backend (3000). You can run it alongside direct mode or collector mode to test distributed tracing across services. If you want to focus on the Python service alone, stop any running Node.js services first with Ctrl+C.

1. Install dependencies

   The setup script creates a virtual environment and installs dependencies:

   npm run python:install

2. Configure environment

   npm run python:setup

   Then edit python-service/.env and add your Sentry DSN:

   SENTRY_DSN=https://YOUR_PUBLIC_KEY@YOUR-ORG-ID.ingest.us.sentry.io/YOUR-PROJECT-ID
   DATABASE_URL=postgresql://user:password@host/database

   That’s all you need!

   Notice there are no OTEL_EXPORTER_OTLP_* environment variables. The OTLP integration extracts the endpoint from your DSN automatically.

3. Start the service

   npm run python

   You should see output like:

   📡 Service: python-inventory-service
   🔭 Sentry OTLP integration initialized
   ✅ Flask app running on http://localhost:3003

What’s Happening Behind the Scenes

The Instrumentation File

The magic happens in python-service/src/instrument.py. Here’s the key setup:

# From python-service/src/instrument.py

import sentry_sdk
from sentry_sdk.integrations.otlp import OTLPIntegration

# OpenTelemetry auto-instrumentation
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor

# Initialize Sentry with OTLP integration
sentry_sdk.init(
    dsn=os.environ.get("SENTRY_DSN"),
    environment=os.environ.get("ENVIRONMENT", "development"),
    send_default_pii=True,
    enable_logs=True,
    integrations=[
        OTLPIntegration(),
    ],
)

# Set up OpenTelemetry auto-instrumentation
FlaskInstrumentor().instrument()
RequestsInstrumentor().instrument()
SQLAlchemyInstrumentor().instrument()

What the OTLPIntegration Does Automatically

When you add OTLPIntegration() to your Sentry SDK init, it:

1. Extracts the OTLP endpoint from your DSN (no manual configuration needed!)
2. Configures the SpanExporter to send traces to Sentry
3. Sets up propagators for distributed tracing (W3C traceparent/baggage)
4. Links traces with errors so exceptions are connected to their trace context

Don't Double-Instrument

When using the OTLP integration, do not also configure tracing through the Sentry SDK’s native tracing features. The OTLP integration handles all trace exports.

Comparison: Python vs Node.js Setup

Here’s why the Python OTLP integration is simpler:

Python (with OTLPIntegration)

# .env - just ONE line needed for Sentry!
SENTRY_DSN=https://key@org.ingest.us.sentry.io/project

# Python - 3 lines of Sentry config
sentry_sdk.init(
    dsn=os.environ.get("SENTRY_DSN"),
    integrations=[OTLPIntegration()],
)

Node.js (Direct SDK)

# .env - FOUR lines needed for Sentry!
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://org.ingest.us.sentry.io/api/project/integration/otlp/v1/logs
OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-sentry-auth=sentry sentry_key=key
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://org.ingest.us.sentry.io/api/project/integration/otlp/v1/traces
OTEL_EXPORTER_OTLP_TRACES_HEADERS=x-sentry-auth=sentry sentry_key=key

// Node.js - manual exporter configuration
const traceExporter = new OTLPTraceExporter({
  url: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
});
const logExporter = new OTLPLogExporter({
  url: process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
});

Testing the Integration

1. Generate traffic

   # Check service health
   curl http://localhost:3003/health
   
   # Get inventory data
   curl http://localhost:3003/api/inventory

2. Verify in Sentry

   1. Go to your Sentry project
   2. Navigate to Explore › Traces
   3. Look for traces from python-inventory-service

Distributed Tracing

The Python service can participate in distributed traces with the Node.js services. The OTLPIntegration automatically:

• Reads incoming traceparent headers from requests
• Propagates trace context to outgoing requests
• Ensures all services appear in the same trace waterfall

When you call the Python service from the Node.js gateway, you’ll see the complete trace across both services in Sentry.

Language Support

The OTLP integration is currently available for:

• Python (3.7+) - sentry-sdk[opentelemetry-otlp]
• JavaScript/Node.js - Coming soon!

Check the Sentry documentation for the latest language support.

What’s Next?

• Try distributed tracing: Call the Python service from the Node.js services and see the complete trace
• Compare approaches: Run direct mode, collector mode, and Python service side-by-side