1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
#!/usr/bin/env python3
"""
Tracing Demo - Frontend Service
Receives user requests and forwards to middleware service.
Demonstrates OpenTelemetry auto-instrumentation with Flask.
"""
from flask import Flask, jsonify, request
import requests
import os
import logging
# OpenTelemetry imports for distributed tracing
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.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.sdk.resources import Resource
# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Initialize OpenTelemetry tracing with resource attributes
# These attributes identify this service in traces
resource = Resource(attributes={
"service.name": "frontend",
"service.namespace": "tracing-demo",
"service.version": "1.0.0",
"deployment.environment": "production"
})
provider = TracerProvider(resource=resource)
# Configure OTLP exporter to send traces to Alloy
otlp_exporter = OTLPSpanExporter(
endpoint=os.getenv('OTEL_EXPORTER_OTLP_ENDPOINT',
'http://alloy.monitoring.svc.cluster.local:4317'),
insecure=True
)
# Batch spans for efficient export
processor = BatchSpanProcessor(otlp_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)
# Get tracer for manual instrumentation if needed
tracer = trace.get_tracer(__name__)
# Create Flask application
app = Flask(__name__)
# Auto-instrument Flask to create spans for HTTP requests
# Exclude health check endpoint to reduce tracing noise
FlaskInstrumentor().instrument_app(app, excluded_urls="/health")
# Auto-instrument requests library to propagate trace context
RequestsInstrumentor().instrument()
# Configuration for downstream services
MIDDLEWARE_URL = os.getenv('MIDDLEWARE_URL',
'http://middleware-service.services.svc.cluster.local:5001')
@app.route('/')
def index():
"""
Health check and service information endpoint.
Returns service metadata.
"""
return jsonify({
"service": "frontend",
"version": "1.0.0",
"message": "Tracing demo frontend service",
"trace_enabled": True,
"middleware_url": MIDDLEWARE_URL
})
@app.route('/health')
def health():
"""
Kubernetes health check endpoint.
Used by readiness and liveness probes.
"""
return jsonify({"status": "healthy"}), 200
@app.route('/api/process', methods=['GET', 'POST'])
def process():
"""
Main processing endpoint that demonstrates distributed tracing.
Forwards request to middleware service and returns combined response.
Creates a custom span to track the processing logic.
"""
# Create a custom span for the processing logic
with tracer.start_as_current_span("frontend-process") as span:
# Add custom attributes to the span for better observability
span.set_attribute("frontend.handler", "process")
# Get request data (supports both GET and POST)
if request.method == 'POST':
data = request.get_json() or {}
else:
data = {"source": "GET request"}
span.set_attribute("frontend.request.method", request.method)
try:
# Call middleware service
# The requests library auto-instrumentation will create a span
# and propagate the trace context via W3C Trace Context headers
logger.info(f"Calling middleware at {MIDDLEWARE_URL}/api/transform")
response = requests.post(
f'{MIDDLEWARE_URL}/api/transform',
json=data,
timeout=10
)
response.raise_for_status()
middleware_data = response.json()
# Record successful call in span
span.set_attribute("frontend.middleware.status", response.status_code)
return jsonify({
"service": "frontend",
"status": "success",
"request_data": data,
"middleware_response": middleware_data
}), 200
except requests.exceptions.RequestException as e:
# Log error and record in span
logger.error(f"Error calling middleware: {e}")
span.set_attribute("frontend.error", str(e))
# Set span status to error
span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))
return jsonify({
"service": "frontend",
"status": "error",
"error": str(e)
}), 500
if __name__ == '__main__':
logger.info("Starting frontend service on port 5000")
logger.info(f"Middleware URL: {MIDDLEWARE_URL}")
logger.info(f"OTLP endpoint: {os.getenv('OTEL_EXPORTER_OTLP_ENDPOINT', 'default')}")
app.run(host='0.0.0.0', port=5000, debug=False)
|
