OTCA Hands-On Lab Answers

git clone https://github.com/open-telemetry/opentelemetry-demo.git
cd opentelemetry-demo
docker compose up --no-build

# Wait ~2 minutes for all services to be healthy
# Frontend UI: http://localhost:8080
# Jaeger UI:   http://localhost:8080/jaeger/ui
# Grafana:     http://localhost:8080/grafana

# Example header value you will see in the browser:
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01

# Breakdown:
#  00                               = version (always 00 in W3C spec)
#  4bf92f3577b34da6a3ce929d0e0e4736  = traceId  (128-bit, 32 hex chars)
#  00f067aa0ba902b7                  = parentSpanId (64-bit, 16 hex chars)
#  01                               = trace-flags: 01=sampled, 00=not sampled

class TraceContextPropagator:

    def inject(self, carrier: dict, context: Context) -> None:
        span = get_current_span(context)
        span_context = span.get_span_context()
        if not span_context.is_valid:
            return
        traceparent = (
            f'00-{span_context.trace_id:032x}'
            f'-{span_context.span_id:016x}'
            f'-{"01" if span_context.trace_flags else "00"}'
        )
        carrier['traceparent'] = traceparent
        if span_context.trace_state:
            carrier['tracestate'] = str(span_context.trace_state)

    def extract(self, carrier: dict) -> Context:
        header = carrier.get('traceparent', '')
        parts = header.split('-')
        if len(parts) != 4 or parts[0] != '00':
            return Context()  # invalid → empty context
        trace_id = int(parts[1], 16)
        span_id  = int(parts[2], 16)
        flags    = int(parts[3], 16)
        span_ctx = SpanContext(
            trace_id=trace_id, span_id=span_id,
            is_remote=True, trace_flags=flags
        )
        return set_span_in_context(NonRecordingSpan(span_ctx))

pip install opentelemetry-sdk \
            opentelemetry-exporter-otlp-proto-grpc \
            opentelemetry-exporter-prometheus \
            opentelemetry-instrumentation-flask \
            prometheus-client \
            flask

import time, random
from flask import Flask, request
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.metrics.view import View

exporter = OTLPMetricExporter(endpoint='http://localhost:4317', insecure=True)
reader   = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)

# View: rename instrument + filter to 2 attributes only
latency_view = View(
    instrument_name='http.server.request.duration',
    name='api.request.duration',
    attribute_keys={'http.request.method', 'http.response.status_code'}
)

provider = MeterProvider(metric_readers=[reader], views=[latency_view])
metrics.set_meter_provider(provider)
meter = metrics.get_meter('my.server', '1.0.0')

# Counter — monotonically increasing
request_counter = meter.create_counter(
    name='http.server.request.total',
    description='Total HTTP requests received',
    unit='1',
)

# Histogram — latency distribution
latency_histogram = meter.create_histogram(
    name='http.server.request.duration',
    description='HTTP request duration in seconds',
    unit='s',
)

app = Flask(__name__)

@app.route('/api/orders', methods=['GET'])
def get_orders():
    start = time.time()
    time.sleep(random.uniform(0.01, 0.3))   # simulate work
    duration = time.time() - start

    attrs = {
        'http.request.method': 'GET',
        'http.response.status_code': 200,
        'service.name': 'order-service'
    }
    request_counter.add(1, attrs)
    latency_histogram.record(duration, attrs)
    return {'orders': []}, 200

if __name__ == '__main__':
    app.run(port=5000)

from opentelemetry.exporter.prometheus import PrometheusMetricReader
from prometheus_client import start_http_server

start_http_server(port=8000)   # exposes /metrics on :8000
reader = PrometheusMetricReader()
provider = MeterProvider(metric_readers=[reader], views=[latency_view])

# Verify:
# curl http://localhost:8000/metrics | grep http_server
#
# api_request_duration_bucket{http_request_method="GET",le="0.05"} 12.0
# http_server_request_total_total{http_request_method="GET",...}   42.0

<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-log4j-appender-2.17</artifactId>
    <version>2.9.0-alpha</version>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-otlp</artifactId>
    <version>1.43.0</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <!-- Console: injects trace_id and span_id via MDC -->
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout
        pattern="%d [%X{trace_id}] [%X{span_id}] %-5level %msg%n"/>
    </Console>

    <!-- OTel appender: ships logs via OTLP to Collector -->
    <OpenTelemetry name="OpenTelemetryAppender"/>
  </Appenders>
  <Loggers>
    <Root level="info">
      <AppenderRef ref="Console"/>
      <AppenderRef ref="OpenTelemetryAppender"/>
    </Root>
  </Loggers>
</Configuration>

receivers:
  filelog:
    include: ["/var/log/myapp/*.log"]
    start_at: beginning
    operators:
      - type: regex_parser
        regex: '^(?P<timestamp>\S+ \S+) \[(?P<trace_id>[a-f0-9]*)\] \[(?P<span_id>[a-f0-9]*)\] (?P<severity>\S+) (?P<message>.*)$'
        timestamp:
          parse_from: attributes.timestamp
          layout: '%Y-%m-%d %H:%M:%S.%f'
        severity:
          parse_from: attributes.severity

processors:
  batch:

exporters:
  logging:
    verbosity: detailed

service:
  pipelines:
    logs:
      receivers: [filelog]
      processors: [batch]
      exporters: [logging]

curl -L -o opentelemetry-javaagent.jar \
  https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar

export OTEL_SERVICE_NAME=order-service
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_LOGS_EXPORTER=otlp
export OTEL_METRICS_EXPORTER=otlp
export OTEL_TRACES_EXPORTER=otlp
export OTEL_TRACES_SAMPLER=parentbased_traceidratio
export OTEL_TRACES_SAMPLER_ARG=1.0
export OTEL_RESOURCE_ATTRIBUTES=deployment.environment=dev,service.version=1.0.0

java -javaagent:./opentelemetry-javaagent.jar \
     -jar target/order-service-1.0.0.jar

# 10% sampling — 1 in ~10 requests generates a trace
export OTEL_TRACES_SAMPLER=parentbased_traceidratio
export OTEL_TRACES_SAMPLER_ARG=0.1

# Drop everything
export OTEL_TRACES_SAMPLER=always_off

# Sample everything (default for dev)
export OTEL_TRACES_SAMPLER=always_on

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.trace import StatusCode

# SDK bootstrap
exporter = OTLPSpanExporter(endpoint='http://localhost:4317', insecure=True)
provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(exporter))
trace.set_tracer_provider(provider)

tracer = trace.get_tracer('com.myapp.payments', '1.0.0')


def process_payment(order_id: str, amount: float) -> dict:
    with tracer.start_as_current_span('payments.process') as span:
        # Semantic convention attributes
        span.set_attribute('order.id', order_id)
        span.set_attribute('payment.amount', amount)
        span.set_attribute('payment.currency', 'USD')

        # Span event — timestamped annotation (not an error)
        span.add_event('payment.validation.started')

        try:
            result = call_payment_gateway(order_id, amount)
            span.add_event('payment.gateway.responded', {
                'gateway.response_code': result['code']
            })
            # Do NOT set OK unless you explicitly want to mark success
            return result
        except Exception as e:
            span.record_exception(e)   # adds exception event with stacktrace
            span.set_status(StatusCode.ERROR, f'Payment declined: {str(e)}')
            raise


def call_payment_gateway(order_id, amount):
    # Child span — CLIENT kind for outbound calls
    with tracer.start_as_current_span(
        'payments.gateway.charge',
        kind=trace.SpanKind.CLIENT
    ) as child:
        child.set_attribute('server.address', 'gateway.example.com')
        child.set_attribute('server.port', 443)
        return {'code': '00', 'auth_code': 'ABC123'}

version: '3.8'
services:
  jaeger:
    image: jaegertracing/all-in-one:latest
    environment:
      - COLLECTOR_OTLP_ENABLED=true
    ports:
      - '16686:16686'   # Jaeger UI
      - '4317:4317'     # OTLP gRPC

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    command: ['--config=/etc/otelcol-contrib/config.yaml']
    volumes:
      - ./collector.yaml:/etc/otelcol-contrib/config.yaml
    ports:
      - '4318:4318'   # OTLP HTTP (app → collector)
      - '8888:8888'   # Collector internal metrics
    depends_on: [jaeger]

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

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  memory_limiter:          # ← MUST be first
    limit_mib: 512
    spike_limit_mib: 128
    check_interval: 5s
  batch:                   # ← MUST be last
    timeout: 10s
    send_batch_size: 1024

exporters:
  otlp/jaeger:
    endpoint: jaeger:4317
    tls:
      insecure: true
  prometheus:
    endpoint: 0.0.0.0:8889
  logging:
    verbosity: detailed

extensions:
  health_check:
    endpoint: 0.0.0.0:13133

service:
  extensions: [health_check]
  pipelines:
    traces:
      receivers:  [otlp]
      processors: [memory_limiter, batch]
      exporters:  [otlp/jaeger, logging]
    metrics:
      receivers:  [otlp]
      processors: [memory_limiter, batch]
      exporters:  [prometheus, logging]
    logs:
      receivers:  [otlp]
      processors: [memory_limiter, batch]
      exporters:  [logging]

# Install (macOS)
brew install equinix-labs/otel-cli/otel-cli

# Send a test span
otel-cli exec \
  --service my-test-service \
  --name 'test.operation' \
  --attrs 'http.request.method=GET,http.response.status_code=200' \
  --endpoint http://localhost:4318 \
  -- echo 'hello from otel-cli'

# Verify health check
curl http://localhost:13133/
# {"status":"Server available"}

apiVersion: 1
datasources:
  - name: Prometheus
    type: prometheus
    url: http://prometheus:9090
    jsonData:
      exemplarTraceIdDestinations:
        - name: trace_id
          datasourceUid: jaeger

  - name: Jaeger
    type: jaeger
    uid: jaeger
    url: http://jaeger:16686