Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegación

Observabilidad

Ejemplos de OpenTelemetry

Ejemplos de estándares de observabilidad OpenTelemetry incluyendo instrumentación, trazado, métricas y logging en múltiples lenguajes y frameworks

Ejemplos

Entradas de esta colección

CódigojavascriptIntermedio

Instrumentación OpenTelemetry Node.js

Configuración completa de OpenTelemetry para aplicaciones Node.js incluyendo instrumentación automática y manual

Dificultad

7/10

Tiempo estimado

45 min

Etiquetas

opentelemetry, nodejs, observability, tracing

Requisitos previos

Node.js, Express, Docker, Monitoring concepts

javascript
// OpenTelemetry Node.js Complete Setup
// Comprehensive instrumentation for Node.js applications

// 1. package.json dependencies
const packageJson = {
  "dependencies": {
    "@opentelemetry/api": "^1.7.0",
    "@opentelemetry/sdk-node": "^0.41.0",
    "@opentelemetry/auto-instrumentations": "^0.39.0",
    "@opentelemetry/exporter-jaeger": "^1.17.0",
    "@opentelemetry/exporter-prometheus": "^0.41.0",
    "@opentelemetry/exporter-otlp-grpc": "^0.41.0",
    "@opentelemetry/exporter-otlp-http": "^0.41.0",
    "@opentelemetry/instrumentation-express": "^0.31.0",
    "@opentelemetry/instrumentation-http": "^0.41.0",
    "@opentelemetry/instrumentation-mongodb": "^0.36.0",
    "@opentelemetry/instrumentation-redis": "^0.35.0",
    "@opentelemetry/instrumentation-pg": "^0.36.0",
    "@opentelemetry/semantic-conventions": "^1.17.0"
  }
};

// 2. otel-setup.js - Main instrumentation setup
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-http');
const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');
const { Resource } = require('@opentelemetry/resources');
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
const { trace, context, SpanKind } = require('@opentelemetry/api');

// Configure service resource
const resource = new Resource({
  [SemanticResourceAttributes.SERVICE_NAME]: 'my-nodejs-app',
  [SemanticResourceAttributes.SERVICE_VERSION]: '1.0.0',
  [SemanticResourceAttributes.SERVICE_INSTANCE_ID]: process.env.HOSTNAME || 'unknown',
  [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV || 'development',
  [SemanticResourceAttributes.HOST_NAME]: process.env.HOSTNAME,
  [SemanticResourceAttributes.PROCESS_PID]: process.pid,
});

// Initialize OpenTelemetry SDK
const sdk = new NodeSDK({
  resource,
  instrumentations: [getNodeAutoInstrumentations()],
  traceExporter: new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || 'http://localhost:4318/v1/traces',
    headers: {
      'api-key': process.env.OTEL_API_KEY,
    },
  }),
  metricExporter: new PrometheusExporter({
    port: 9464,
    endpoint: '/metrics',
  }),
  sampler: {
    type: 'traceidratio',
    options: {
      ratio: parseFloat(process.env.OTEL_TRACES_SAMPLER_ARG || '1.0'),
    },
  },
  spanLimits: {
    attributeCountLimit: 100,
    eventCountLimit: 1000,
    linkCountLimit: 100,
  },
});

sdk.start();

console.log('OpenTelemetry instrumentation started');

// 3. Express application with OpenTelemetry
const express = require('express');
const tracer = trace.getTracer('express-app');
const { SpanStatusCode } = require('@opentelemetry/api');

const app = express();
app.use(express.json());

// Custom middleware for OpenTelemetry tracing
function telemetryMiddleware(req, res, next) {
  const tracer = trace.getTracer('express-middleware');
  const span = tracer.startSpan('http-request', {
    kind: SpanKind.SERVER,
    attributes: {
      'http.method': req.method,
      'http.url': req.url,
      'http.target': req.path,
      'user_agent': req.get('user-agent'),
      'http.remote_addr': req.ip,
    },
  });

  // Add span to context
  context.with(trace.setActiveContext(span), () => {
    // Add response listener
    res.on('finish', () => {
      span.setAttributes({
        'http.status_code': res.statusCode,
        'http.response_content_length': res.get('content-length'),
      });

      if (res.statusCode >= 400) {
        span.setStatus({
          code: SpanStatusCode.ERROR,
          message: `HTTP ${res.statusCode}`,
        });
      }

      span.end();
    });

    next();
  });
}

app.use(telemetryMiddleware);

// Manual tracing for custom business logic
async function processUserOrder(userId, orderId) {
  const tracer = trace.getTracer('order-service');
  const span = tracer.startSpan('process-order', {
    attributes: {
      'user.id': userId,
      'order.id': orderId,
    },
  });

  try {
    // Database operation span
    const dbSpan = tracer.startSpan('database-query', {
      attributes: {
        'db.system': 'postgresql',
        'db.operation': 'SELECT',
      },
    });

    // Simulate database query
    await new Promise(resolve => setTimeout(resolve, 100));

    const order = { id: orderId, userId, total: 100 };

    dbSpan.setAttributes({
      'db.rows_returned': 1,
    });
    dbSpan.end();

    span.setAttributes({
      'order.total': order.total,
      'order.currency': 'USD',
    });

    return order;
  } catch (error) {
    span.recordException(error);
    span.setStatus({
      code: SpanStatusCode.ERROR,
      message: error.message,
    });
    throw error;
  } finally {
    span.end();
  }
}

// API routes
app.get('/users/:userId/orders/:orderId', async (req, res) => {
  const tracer = trace.getTracer('api');
  const span = tracer.startSpan('get-user-order', {
    kind: SpanKind.SERVER,
    attributes: {
      'user.id': req.params.userId,
      'order.id': req.params.orderId,
    },
  });

  try {
    const order = await processUserOrder(req.params.userId, req.params.orderId);
    res.json({ success: true, order });
  } catch (error) {
    span.recordException(error);
    res.status(500).json({ error: error.message });
  } finally {
    span.end();
  }
});

// 4. Custom metrics collection
const { MeterProvider } = require('@opentelemetry/sdk-metrics');
const { AggregationTemporality, MetricReader, PeriodicExportingMetricReader } = require('@opentelemetry/sdk-metrics');

// Custom metrics
const meter = tracer.getMeter('application-metrics');

// Counter for business metrics
const orderCounter = meter.createCounter('orders_processed', {
  description: 'Number of orders processed',
  unit: '1',
});

// Histogram for response times
const responseTimeHistogram = meter.createHistogram('http_request_duration', {
  description: 'HTTP request duration',
  unit: 'ms',
  advice: {
    explicitBucketBoundaries: [10, 50, 100, 200, 500, 1000, 2000, 5000],
  },
});

// Gauge for system resources
const activeConnectionsGauge = meter.createUpDownCounter('active_connections', {
  description: 'Number of active connections',
  unit: '1',
});

// Example usage
function trackOrderProcessing(orderId, amount) {
  orderCounter.add(1, {
    'order.id': orderId,
    'order.amount': amount.toString(),
  });
}

function trackResponseTime(duration, route, method) {
  responseTimeHistogram.record(duration, {
    'http.route': route,
    'http.method': method,
  });
}

// 5. Database instrumentation
const { registerInstrumentations } = require('@opentelemetry/instrumentation-pg');
const { Pool } = require('pg');

// Register PostgreSQL instrumentation
registerInstrumentations({
  tracerProvider: sdk._tracerProvider,
  meterProvider: sdk._meterProvider,
});

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

async function queryDatabase(sql, params = []) {
  const tracer = trace.getTracer('database');
  const span = tracer.startSpan('database-query', {
    attributes: {
      'db.system': 'postgresql',
      'db.statement': sql,
    },
  });

  try {
    const start = Date.now();
    const result = await pool.query(sql, params);
    const duration = Date.now() - start;

    span.setAttributes({
      'db.query.duration_ms': duration,
      'db.rows_affected': result.rowCount || result.rows?.length || 0,
    });

    return result;
  } catch (error) {
    span.recordException(error);
    throw error;
  } finally {
    span.end();
  }
}

// 6. Error handling and logging with correlation
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json(),
    winston.format.printf(({ timestamp, level, message, traceId, spanId, ...meta }) => {
      return JSON.stringify({
        timestamp,
        level,
        message,
        traceId,
        spanId,
        ...meta,
      });
    })
  ),
  transports: [
    new winston.transports.Console(),
  ],
});

// Logger middleware that adds trace context
function loggingMiddleware(req, res, next) {
  const activeSpan = trace.getActiveSpan();
  const traceId = activeSpan?.spanContext().traceId;
  const spanId = activeSpan?.spanContext().spanId;

  // Add trace context to request
  req.traceId = traceId;
  req.spanId = spanId;

  // Log the request
  logger.info('HTTP Request', {
    method: req.method,
    url: req.url,
    userAgent: req.get('user-agent'),
    traceId,
    spanId,
  });

  // Override res.end to log response
  const originalEnd = res.end;
  res.end = function(...args) {
    logger.info('HTTP Response', {
      statusCode: res.statusCode,
      traceId,
      spanId,
    });
    originalEnd.apply(this, args);
  };

  next();
}

app.use(loggingMiddleware);

// 7. Environment configuration
// .env file
OTEL_SERVICE_NAME=my-nodejs-app
OTEL_SERVICE_VERSION=1.0.0
OTEL_RESOURCE_ATTRIBUTES=service.namespace=production,service.instance.id=instance-1
OTEL_TRACES_EXPORTER=otlp
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/v1/traces
OTEL_METRICS_EXPORTER=prometheus
OTEL_LOGS_EXPORTER=console
OTEL_TRACES_SAMPLER=traceidratio
OTEL_TRACES_SAMPLER_ARG=1.0
OTEL_NODE_RESOURCE_DETECTORS=env,host,os
OTEL_EXPORTER_JAEGER_AGENT_HOST=localhost
OTEL_EXPORTER_JAEGER_AGENT_PORT=6831

// 8. Docker Compose for local development
// docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://otel-collector:4318/v1/traces
      - OTEL_SERVICE_NAME=my-nodejs-app
      - DATABASE_URL=postgresql://postgres:password@postgres:5432/myapp
    depends_on:
      - otel-collector
      - postgres
    volumes:
      - .:/app
      - /app/node_modules

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    command:
      - --config=/etc/otel-collector-config.yaml
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "4317:4317"   # OTLP gRPC receiver
      - "4318:4318"   # OTLP HTTP receiver
      - "8888:8888"   # Prometheus metrics
      - "8889:8889"   # Prometheus exporter
      - "13133:13133" # health check extension
      - "55679:55679" # zpages extension
    depends_on:
      - jaeger
      - prometheus

  jaeger:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686"
      - "14268:14268"
    environment:
      - COLLECTOR_OTLP_ENABLED=true

  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

// 9. Collector configuration
// otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

  prometheus:
    config:
      scrape_configs:
        - job_name: 'otel-collector'
          static_configs:
            - targets: ['localhost:8888', 'localhost:9464']

processors:
  batch:
  memory_limiter:
    limit_mib: 512

extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  zpages:
    endpoint: 0.0.0.0:55679

exporters:
  otlphttp:
    endpoint: "https://your-otel-endpoint.com/v1/traces"
    headers:
      "Authorization": "Bearer YOUR_TOKEN"
  prometheus:
    endpoint: "0.0.0.0:8889"
  logging:
    loglevel: info

service:
  extensions: [health_check, zpages]
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlphttp, logging]
    metrics:
      receivers: [otlp, prometheus]
      processors: [memory_limiter, batch]
      exporters: [prometheus, logging]

// 10. Testing with OpenTelemetry
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { InMemorySpanExporter, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');

// Setup for testing
function setupTestTracing() {
  const memoryExporter = new InMemorySpanExporter();
  const testSdk = new NodeSDK({
    instrumentations: [getNodeAutoInstrumentations()],
    spanProcessors: [new SimpleSpanProcessor(memoryExporter)],
  });

  testSdk.start();

  return { testSdk, memoryExporter };
}

// Example test
const { expect } = require('chai');

describe('OpenTelemetry Tracing', () => {
  let sdk, exporter;

  beforeEach(() => {
    ({ sdk, exporter } = setupTestTracing());
  });

  afterEach(() => {
    sdk.shutdown();
  });

  it('should trace HTTP requests', async () => {
    const response = await fetch('http://localhost:3000/users/123/orders/456');
    expect(response.status).to.equal(200);

    const spans = exporter.getFinishedSpans();
    expect(spans.length).to.be.greaterThan(0);

    const httpSpan = spans.find(span => span.name === 'HTTP GET');
    expect(httpSpan).to.exist;
    expect(httpSpan.attributes['http.status_code']).to.equal(200);
  });

  it('should include trace context in logs', async () => {
    const response = await fetch('http://localhost:3000/users/123/orders/456');
    expect(response.status).to.equal(200);

    const spans = exporter.getFinishedSpans();
    const span = spans[0];

    expect(span.spanContext().traceId).to.be.a('string');
    expect(span.spanContext().spanId).to.be.a('string');
  });
});
CódigopythonIntermedio

Instrumentación OpenTelemetry Python

Configuración completa de OpenTelemetry para aplicaciones Python incluyendo Flask, Django y frameworks asíncronos

Dificultad

7/10

Tiempo estimado

45 min

Etiquetas

opentelemetry, python, observability, flask

Requisitos previos

Python, Flask, Async programming, Monitoring concepts

python
# OpenTelemetry Python Complete Setup
# Comprehensive instrumentation for Python applications

# 1. requirements.txt
opentelemetry-api==1.21.0
opentelemetry-sdk==1.21.0
opentelemetry-instrumentation==0.42b0
opentelemetry-instrumentation-flask==0.42b0
opentelemetry-instrumentation-django==0.42b0
opentelemetry-instrumentation-requests==0.42b0
opentelemetry-instrumentation-asyncpg==0.42b0
opentelemetry-instrumentation-psycopg2==0.42b0
opentelemetry-instrumentation-redis==0.42b0
opentelemetry-instrumentation-mysql==0.42b0
opentelemetry-exporter-jaeger==1.21.0
opentelemetry-exporter-prometheus==1.21.0
opentelemetry-exporter-otlp==1.21.0
opentelemetry-propagator-b3==1.21.0
opentelemetry-propagator-jaeger==1.21.0

# 2. otel_setup.py - Main instrumentation setup
import os
from opentelemetry import trace, metrics, logs
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.logs import LoggerProvider, LoggingHandler
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.exporter.prometheus import PrometheusMetricReader
from opentelemetry.exporter.otlp.proto.grpc.exporter import OTLPSpanExporter
from opentelemetry.instrumentation.auto_instrumentation import AutoInstrumenter
from opentelemetry import context
from opentelemetry.propagate import inject, extract
import logging

def setup_opentelemetry():
    """Setup OpenTelemetry with all necessary components"""

    # Configure service resource
    resource = Resource.create({
        "service.name": os.getenv("OTEL_SERVICE_NAME", "python-app"),
        "service.version": os.getenv("OTEL_SERVICE_VERSION", "1.0.0"),
        "service.instance.id": os.getenv("HOSTNAME", "localhost"),
        "deployment.environment": os.getenv("OTEL_ENVIRONMENT", "development"),
        "host.name": os.getenv("HOSTNAME", "localhost"),
        "process.pid": os.getpid(),
    })

    # Setup Tracing
    tracer_provider = TracerProvider(resource=resource)

    # Add Jaeger exporter
    jaeger_exporter = JaegerExporter(
        agent_host_name=os.getenv("JAEGER_AGENT_HOST", "localhost"),
        agent_port=int(os.getenv("JAEGER_AGENT_PORT", "6831")),
    )

    # Add OTLP exporter
    otlp_exporter = OTLPSpanExporter(
        endpoint=os.getenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", "http://localhost:4318/v1/traces"),
        headers={
            "api-key": os.getenv("OTEL_API_KEY", ""),
        }
    )

    tracer_provider.add_span_processor(
        BatchSpanProcessor(jaeger_exporter)
    )
    tracer_provider.add_span_processor(
        BatchSpanProcessor(otlp_exporter)
    )

    trace.set_tracer_provider(tracer_provider)

    # Setup Metrics
    metric_reader = PrometheusMetricReader()

    meter_provider = MeterProvider(resource=resource)
    meter_provider.register_metric_reader(metric_reader)
    metrics.set_meter_provider(meter_provider)

    # Setup Logging
    logger_provider = LoggerProvider(resource=resource)
    logs.set_logger_provider(logger_provider)

    # Configure Python logging to use OpenTelemetry
    logging_handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
    logging.getLogger().addHandler(logging_handler)

    # Auto-instrumentation
    auto_instrumenter = AutoInstrumenter()
    auto_instrumenter.instrument()

    return tracer_provider, meter_provider, logger_provider

# Initialize OpenTelemetry
if __name__ == "__main__":
    setup_opentelemetry()

# 3. Flask application with OpenTelemetry
from flask import Flask, request, jsonify
from opentelemetry import trace
from opentelemetry.trace import SpanKind, StatusCode
from opentelemetry.propagate import inject
import time
import requests

app = Flask(__name__)

# Get tracer
tracer = trace.get_tracer(__name__)

# Custom middleware for tracing
@app.before_request
def before_request():
    """Extract trace context from incoming request"""
    span = trace.get_current_span()
    span.set_attribute("http.method", request.method)
    span.set_attribute("http.url", request.url)
    span.set_attribute("http.target", request.path)
    span.set_attribute("http.user_agent", request.headers.get("User-Agent", ""))
    span.set_attribute("http.remote_addr", request.remote_addr)

@app.after_request
def after_request(response):
    """Add response attributes to span"""
    span = trace.get_current_span()
    span.set_attribute("http.status_code", response.status_code)

    if response.status_code >= 400:
        span.set_status(
            StatusCode.ERROR,
            f"HTTP {response.status_code}"
        )

    return response

# Manual tracing for business logic
def process_user_payment(user_id, amount, payment_method):
    """Process user payment with tracing"""
    with tracer.start_as_current_span(
        "process-payment",
        kind=trace.SpanKind.INTERNAL
    ) as span:
        span.set_attributes({
            "user.id": str(user_id),
            "payment.amount": str(amount),
            "payment.method": payment_method,
        })

        try:
            # Simulate payment processing
            with tracer.start_as_current_span("payment-gateway-call"):
                time.sleep(0.1)  # Simulate network call
                payment_id = f"pay_{int(time.time())}"

                span.set_attribute("payment.id", payment_id)
                span.set_attribute("payment.status", "success")

                return {
                    "payment_id": payment_id,
                    "status": "success",
                    "amount": amount
                }

        except Exception as e:
            span.record_exception(e)
            span.set_status(StatusCode.ERROR, str(e))
            raise

# API routes
@app.route("/api/users/<int:user_id>/payments", methods=["POST"])
def create_payment(user_id):
    """Create payment for user"""
    with tracer.start_as_current_span(
        "create-payment-endpoint",
        kind=trace.SpanKind.SERVER
    ) as span:
        try:
            data = request.get_json()
            amount = data.get("amount")
            payment_method = data.get("payment_method")

            if not amount or not payment_method:
                return jsonify({"error": "Missing required fields"}), 400

            result = process_user_payment(user_id, amount, payment_method)

            # Create metric counter
            meter = metrics.get_meter(__name__)
            payment_counter = meter.create_counter("payments_created")
            payment_counter.add(1, {
                "payment.method": payment_method,
                "user.id": str(user_id),
            })

            return jsonify(result)

        except Exception as e:
            return jsonify({"error": str(e)}), 500

# Propagate context to external services
@app.route("/api/external-service")
def call_external_service():
    """Example of propagating trace context to external service"""
    with tracer.start_as_current_span("external-service-call"):
        headers = {}
        inject(headers)  # Inject trace context into headers

        response = requests.get(
            "https://api.example.com/data",
            headers=headers
        )

        return jsonify({
            "status": response.status_code,
            "data": response.json() if response.headers.get("content-type", "").startswith("application/json") else None
        })

# 4. Custom metrics collection
from opentelemetry.metrics import Observation

def setup_custom_metrics():
    """Setup custom application metrics"""
    meter = metrics.get_meter("application-metrics")

    # Counter for business metrics
    order_counter = meter.create_counter(
        "orders_processed",
        description="Number of orders processed"
    )

    # Histogram for response times
    response_time_histogram = meter.create_histogram(
        "http_request_duration_seconds",
        description="HTTP request duration in seconds"
    )

    # Gauge for active users
    active_users_gauge = meter.create_up_down_counter(
        "active_users",
        description="Number of active users"
    )

    return {
        "order_counter": order_counter,
        "response_time_histogram": response_time_histogram,
        "active_users_gauge": active_users_gauge
    }

# Initialize metrics
metrics_data = setup_custom_metrics()

# 5. Async application with OpenTelemetry
import asyncio
import aiohttp
from opentelemetry.instrumentation.aiohttp.client import AioHttpClientInstrumentor

# Instrument aiohttp client
AioHttpClientInstrumentor().instrument()

async def async_request_example():
    """Example of async request with tracing"""
    tracer = trace.get_tracer(__name__)

    with tracer.start_as_current_span("async-http-request"):
        async with aiohttp.ClientSession() as session:
            headers = {}
            inject(headers)  # Inject trace context

            async with session.get(
                "https://api.example.com/data",
                headers=headers
            ) as response:
                data = await response.json()
                return data

# 6. Database instrumentation
import asyncpg
from opentelemetry.instrumentation.asyncpg import AsyncPGInstrumentor

# Instrument asyncpg
AsyncPGInstrumentor().instrument()

async def database_example():
    """Example of database operation with tracing"""
    tracer = trace.get_tracer(__name__)

    with tracer.start_as_current_span("database-operation") as span:
        span.set_attributes({
            "db.system": "postgresql",
            "db.operation": "SELECT",
            "db.name": "myapp"
        })

        conn = await asyncpg.connect("postgresql://user:pass@localhost/myapp")

        try:
            result = await conn.fetch(
                "SELECT * FROM users WHERE id = $1",
                123
            )

            span.set_attributes({
                "db.rows_returned": len(result)
            })

            return result

        finally:
            await conn.close()

# 7. Background task instrumentation
import threading
from concurrent.futures import ThreadPoolExecutor

def background_task_with_tracing(task_id, data):
    """Background task with manual tracing"""
    tracer = trace.get_tracer(__name__)

    # Create new span for background task
    with tracer.start_as_current_span(
        f"background-task-{task_id}",
        kind=trace.SpanKind.INTERNAL
    ) as span:
        span.set_attribute("task.id", str(task_id))
        span.set_attribute("task.data_size", len(str(data)))

        # Simulate work
        time.sleep(0.5)

        # Record some metrics
        metrics_data["order_counter"].add(1, {
            "task.type": "background",
            "task.status": "completed"
        })

        return f"Task {task_id} completed"

@app.route("/api/tasks/<int:task_id>", methods=["POST"])
def create_background_task(task_id):
    """Create and run background task"""
    data = request.get_json() or {}

    # Use thread pool for background tasks
    with ThreadPoolExecutor(max_workers=4) as executor:
        future = executor.submit(
            background_task_with_tracing,
            task_id,
            data
        )

        # In a real app, you'd store the future and check status later
        result = future.result(timeout=10)

        return jsonify({"result": result})

# 8. Environment configuration
# .env
OTEL_SERVICE_NAME=python-app
OTEL_SERVICE_VERSION=1.0.0
OTEL_RESOURCE_ATTRIBUTES=service.namespace=production,service.instance.id=instance-1
OTEL_TRACES_EXPORTER=jaeger,otlp
OTEL_EXPORTER_JAEGER_AGENT_HOST=localhost
OTEL_EXPORTER_JAEGER_AGENT_PORT=6831
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/v1/traces
OTEL_METRICS_EXPORTER=prometheus
OTEL_LOGS_EXPORTER=console
OTEL_PYTHON_IDE_AUTO_INSTRUMENTATION=true
OTEL_LOG_LEVEL=INFO

# 9. Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Copy requirements and install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY .

# Expose port
EXPOSE 5000

# Run the application
CMD ["python", "app.py"]

# 10. Testing with OpenTelemetry
import unittest
from unittest.mock import patch
from opentelemetry.sdk.trace.export import InMemorySpanExporter, SimpleSpanProcessor
from opentelemetry.sdk.trace import TracerProvider

class TestTracing(unittest.TestCase):

    def setUp(self):
        """Setup test tracer"""
        self.memory_exporter = InMemorySpanExporter()

        tracer_provider = TracerProvider()
        tracer_provider.add_span_processor(
            SimpleSpanProcessor(self.memory_exporter)
        )

        trace.set_tracer_provider(tracer_provider)

    def test_manual_tracing(self):
        """Test manual span creation"""
        tracer = trace.get_tracer(__name__)

        with tracer.start_as_current_span("test-span") as span:
            span.set_attribute("test.attribute", "test-value")

        spans = self.memory_exporter.get_finished_spans()
        self.assertEqual(len(spans), 1)
        self.assertEqual(spans[0].name, "test-span")
        self.assertEqual(spans[0].attributes["test.attribute"], "test-value")

    def test_context_propagation(self):
        """Test trace context propagation"""
        tracer = trace.get_tracer(__name__)

        with tracer.start_as_current_span("parent-span"):
            with tracer.start_as_current_span("child-span") as child_span:
                pass

        spans = self.memory_exporter.get_finished_spans()
        self.assertEqual(len(spans), 2)

        # Check that child has same trace ID as parent
        parent_trace_id = spans[0].get_span_context().trace_id
        child_trace_id = spans[1].get_span_context().trace_id
        self.assertEqual(parent_trace_id, child_trace_id)

if __name__ == "__main__":
    setup_opentelemetry()
    app.run(debug=True, port=5000)

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Tema

Verificar una actualización de instrumentación OpenTelemetry

Inventaría atributos antiguos, migra convenciones semánticas, comprueba la propagación y revisa una traza real antes de publicar cambios de instrumentación.

Tema

Revisión e integración de un componente de sorteos autoalojado

Revisa la configuración, las respuestas de ejemplo, la legibilidad y el diseño adaptable antes de entregar los archivos y las pruebas de integración del sorteo.

Tema

Modelos farmacocineticos docentes y revision de resultados

Explora formulas farmacocineticas, supuestos de modelo y coherencia de resultados para docencia o QA, sin dar dosis ni consejo clinico.

Tema

Herramientas de cifrado clásico y moderno

Practica cifrados seguros para educación o CTF comparando transformaciones clásicas reversibles con cifrado moderno y sus límites de seguridad.

Inicio
Herramientas3212
Ejemplos593
Visualizaciones471
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web193

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Media

Conversor de Audio en Lote

Convierte múltiples archivos de audio entre diferentes formatos como MP3, WAV, FLAC, AAC, OGG, Opus con configuración de calidad y procesamiento por lotes

Media

Conversor WAV en Lote

Convertir múltiples archivos WAV a formatos MP3, OGG, AAC, M4A, OPUS y FLAC con configuración de calidad, control de bitrate y procesamiento por lotes

Media

Convertidor de AAC a OGG

Convierte archivos de audio AAC al formato OGG Vorbis con controles de calidad y canales

Media

Cambiar códec de audio

Cambiar el códec dentro de un formato de salida elegido

Media

Convertidor de Formato de Audio

Convierte archivos de audio entre diferentes formatos como MP3, WAV, FLAC, AAC, OGG con configuración de calidad y ajuste de volumen

Media

Creador de Tonos

Recorta y aplica fades para tono

Media

Audio CBR

Re-codifica audio con bitrate constante (CBR)

Media

Convertidor de FLAC a OGG

Convierte audio FLAC a OGG Vorbis con opciones de bitrate, muestreo y canales

DevOps

Muestras de Análisis de Logs ELK Stack

Muestras completas de ELK Stack para agregación, procesamiento y visualización de logs en sistemas distribuidos

Monitoreo y observabilidad

Ejemplos de Datadog Monitoring

Ejemplos completos de configuración de monitoring y observabilidad de Datadog incluyendo APM, logs, métricas y dashboards

Medios

Muestras OGG Vorbis Sin Derechos de Autor

Colección de audio OGG Vorbis de código abierto para pruebas y desarrollo, con compresión excelente incluyendo sonidos de la naturaleza y música de meditación

Monitoreo de errores

Ejemplos Sentry Error Tracking

Configuración completa de Sentry error tracking y performance monitoring con integraciones SDK para varias plataformas

Java

Ejemplos de Manejo de Errores Android Java

Ejemplos de manejo de errores Android Java incluyendo manejo de excepciones, registro y validación de parámetros

Kotlin

Ejemplos de Manejo de Errores Android Kotlin

Ejemplos de manejo de errores Android Kotlin incluyendo captura de excepciones, registro y validación de parámetros