Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHDERUPTENFRES

Elysia Tools

导航

可观测性

OpenTelemetry 示例

OpenTelemetry 可观测性标准示例,包括多种语言和框架的追踪、指标和日志

案例

这个案例集合中的条目

代码javascript中等

Node.js OpenTelemetry 集成

Node.js 应用程序的完整 OpenTelemetry 设置,包括自动和手动集成

难度

7/10

预计时间

45 min

标签

opentelemetry, nodejs, observability, tracing

前置条件

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');
  });
});
代码python中等

Python OpenTelemetry 集成

Python 应用程序的完整 OpenTelemetry 设置,包括 Flask、Django 和异步框架

难度

7/10

预计时间

45 min

标签

opentelemetry, python, observability, flask

前置条件

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)

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

OpenTelemetry 埋点升级验收工作流

盘点旧属性、迁移 OTel 语义约定、核对链路上下文传播,并用真实 trace 验收跨服务埋点。

专题

药代动力学教学模型与结果核查

用于教学或 QA 的药代公式、模型假设和结果一致性核查,不提供用药剂量、诊断或临床建议。

专题

经典与现代密码工具

在安全的教学或 CTF 场景中比较可逆的经典变换与现代加密,并明确玩具密码不等于安全防护。

专题

文本前后缀与包裹符号批处理,整行整词一次到位

给文本行或词批量添加前后缀,为 SQL、配置和 Markdown 给每个值加引号或反引号包裹,并剥掉粘贴列表带来的编号、符号和装饰。

首页
工具3212
案例593
可视化471
文件查看器103
专题239
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融647

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

潜客测验发布与联系人交接
讣告、悼词与纪念卡的家属复核及交付
本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们

Media

批量音频转换器

批量转换多个音频文件格式,支持 MP3、WAV、FLAC、AAC、OGG、Opus,支持质量设置和批量处理

Media

批量WAV音频转换器

将多个WAV文件批量转换为MP3、OGG、AAC、M4A、OPUS和FLAC格式,支持质量设置、比特率控制和批量处理

Media

AAC 转 OGG 转换器

将 AAC 音频文件转换为 OGG Vorbis 格式,支持质量和声道控制

Media

音频编码切换

在选定输出格式内更换音频编码

Media

音频格式转换器

在不同音频格式之间转换文件,如 MP3、WAV、FLAC、AAC、OGG,支持质量设置和音量调节

Media

铃声制作

裁剪+淡入淡出并导出铃声格式

Media

音频 CBR 转换

使用固定比特率 (CBR) 重新编码音频

Media

FLAC 转 OGG 转换器

将 FLAC 音频转换为 OGG Vorbis,支持比特率、采样率和声道设置

DevOps

ELK Stack 日志分析示例

全面的 ELK Stack(Elasticsearch、Logstash、Kibana)示例,用于分布式系统中的日志聚合、处理和可视化

监控与可观测性

Datadog 监控示例

全面的 Datadog 监控和可观测性配置示例,包括 APM、日志、指标和仪表板

媒体

无版权OGG Vorbis音频样本

用于测试与开发的开源OGG Vorbis音频样本集合,具有出色压缩效果,包含自然声音与冥想音乐

错误监控

Sentry 错误追踪示例

全面的 Sentry 错误追踪和性能监控设置,包含各种平台的 SDK 集成

Java

Android Java 错误处理示例

Android Java 错误处理示例,包括异常处理、日志记录和参数验证

Kotlin

Android Kotlin 错误处理示例

Android Kotlin 错误处理示例,包括异常捕获、日志记录和参数验证