Application Performance Monitoring (APM)

# watchlog_exporter.py
import os
import json
import http.client
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor, SpanExporter, SpanExportResult
from opentelemetry.sdk.resources import Resource
from opentelemetry.trace import Status, StatusCode
from typing import Sequence
import urllib.parse

# Custom JSON exporter for Watchlog
class WatchlogJSONExporter(SpanExporter):
    def __init__(self, endpoint: str, resource: Resource = None):
        self.endpoint = endpoint
        self.resource = resource
        # Parse endpoint URL
        parsed = urllib.parse.urlparse(endpoint)
        self.host = parsed.hostname
        self.port = parsed.port or (443 if parsed.scheme == 'https' else 80)
        self.path = parsed.path
        self.scheme = parsed.scheme
        self.use_ssl = parsed.scheme == 'https'
    
    def export(self, spans: Sequence) -> SpanExportResult:
        if not spans:
            return SpanExportResult.SUCCESS
        
        try:
            # Convert spans to JSON format
            json_data = self._spans_to_json(spans)
            json_str = json.dumps(json_data)
            
            # Send HTTP POST request
            conn = http.client.HTTPConnection(self.host, self.port) if not self.use_ssl else http.client.HTTPSConnection(self.host, self.port)
            
            headers = {
                'Content-Type': 'application/json',
            }
            
            conn.request('POST', self.path, json_str, headers)
            response = conn.getresponse()
            conn.close()
            
            if response.status == 200:
                return SpanExportResult.SUCCESS
            else:
                return SpanExportResult.FAILURE
        except Exception as e:
            import logging
            logging.getLogger(__name__).error(f"Error exporting spans to watchlog: {e}")
            return SpanExportResult.FAILURE
    
    def _spans_to_json(self, spans):
        """Convert OpenTelemetry spans to JSON format (OTLP JSON format)"""
        span_list = []
        
        for span in spans:
            span_data = {
                "traceId": format(span.context.trace_id, '032x'),
                "spanId": format(span.context.span_id, '016x'),
                "name": span.name,
                "kind": "SPAN_KIND_INTERNAL",
                "startTimeUnixNano": str(span.start_time),
                "endTimeUnixNano": str(span.end_time) if span.end_time else str(span.start_time),
                "attributes": self._attributes_to_array(span.attributes) if span.attributes else [],
            }
            
            # Add parent span ID if exists
            if span.parent and span.parent.span_id:
                span_data["parentSpanId"] = format(span.parent.span_id, '016x')
            
            # Add status if exists
            if span.status:
                span_data["status"] = {
                    "code": "STATUS_CODE_ERROR" if span.status.status_code == StatusCode.ERROR else "STATUS_CODE_OK"
                }
                if span.status.description:
                    span_data["status"]["message"] = span.status.description
            
            # Add events if exists
            if span.events:
                span_data["events"] = [
                    {
                        "timeUnixNano": str(event.timestamp),
                        "name": event.name,
                        "attributes": self._attributes_to_array(event.attributes) if event.attributes else []
                    }
                    for event in span.events
                ]
            
            span_list.append(span_data)
        
        # OTLP JSON format
        # Convert resource attributes to array format
        resource_attrs = []
        if self.resource and hasattr(self.resource, 'attributes') and self.resource.attributes:
            resource_attrs = self._attributes_to_array(self.resource.attributes)
        
        return {
            "resourceSpans": [{
                "resource": {
                    "attributes": resource_attrs
                },
                "scopeSpans": [{
                    "spans": span_list
                }]
            }]
        }
    
    def _attributes_to_array(self, attributes):
        """Convert OpenTelemetry attributes to OTLP JSON format array of {key, value}"""
        result = []
        for key, value in attributes.items():
            # OTLP JSON format: {key: string, value: {stringValue, intValue, doubleValue, boolValue, ...}}
            attr_obj = {"key": key}
            
            if isinstance(value, str):
                attr_obj["value"] = {"stringValue": value}
            elif isinstance(value, bool):
                attr_obj["value"] = {"boolValue": value}
            elif isinstance(value, int):
                attr_obj["value"] = {"intValue": str(value)}
            elif isinstance(value, float):
                attr_obj["value"] = {"doubleValue": value}
            elif isinstance(value, bytes):
                attr_obj["value"] = {"bytesValue": value.hex()}
            else:
                # Default to string
                attr_obj["value"] = {"stringValue": str(value)}
            
            result.append(attr_obj)
        return result
    
    def shutdown(self):
        pass

# otel_config.py
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import Resource
from watchlog_exporter import WatchlogJSONExporter

# Your application name
APP_NAME = os.getenv('APP_NAME', 'my-python-service')
# Watchlog agent URL (local: http://localhost:3774 or Docker: http://watchlog-agent:3774)
WATCHLOG_URL = os.getenv('WATCHLOG_URL', 'http://localhost:3774')

# Set up OpenTelemetry
resource = Resource.create({
    "service.name": APP_NAME,
    "service.version": "1.0.0",
})

trace.set_tracer_provider(TracerProvider(resource=resource))

# Configure Watchlog JSON exporter
watchlog_exporter = WatchlogJSONExporter(
    endpoint=f"{WATCHLOG_URL}/apm/{APP_NAME}/v1/traces",
    resource=resource
)

# Use BatchSpanProcessor for production (or SimpleSpanProcessor for testing)
span_processor = BatchSpanProcessor(watchlog_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Flask instrumentation - must be imported after setting up the tracer provider
from opentelemetry.instrumentation.flask import FlaskInstrumentor
FlaskInstrumentor().instrument()

# main.py
# Import OpenTelemetry configuration first
import otel_config

# Now import and use Flask
from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Watchlog APM!"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=6000)

# myproject/__init__.py
import os
import json
import http.client
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor, SpanExporter, SpanExportResult
from opentelemetry.sdk.resources import Resource
from opentelemetry.trace import Status, StatusCode
from typing import Sequence
import urllib.parse

# Custom JSON exporter for Watchlog (same as above)
class WatchlogJSONExporter(SpanExporter):
    # ... (copy the WatchlogJSONExporter class from above)
    pass

# Configure OpenTelemetry
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "django-app"),
})

trace.set_tracer_provider(TracerProvider(resource=resource))

# Get OTLP endpoint from environment variable
APP_NAME = os.getenv('APP_NAME', 'django-app')
WATCHLOG_URL = os.getenv('WATCHLOG_URL', 'http://watchlog-agent:3774')
otlp_endpoint = f"{WATCHLOG_URL}/apm/{APP_NAME}/v1/traces"

# Use custom JSON exporter for Watchlog
watchlog_exporter = WatchlogJSONExporter(endpoint=otlp_endpoint, resource=resource)

# Use BatchSpanProcessor for production (or SimpleSpanProcessor for testing)
span_processor = BatchSpanProcessor(watchlog_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Django instrumentation - must be imported after setting up the tracer provider
from opentelemetry.instrumentation.django import DjangoInstrumentor
DjangoInstrumentor().instrument()

# otel_config.py
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import Resource
from watchlog_exporter import WatchlogJSONExporter

# Your application name
APP_NAME = os.getenv('APP_NAME', 'my-fastapi-service')
WATCHLOG_URL = os.getenv('WATCHLOG_URL', 'http://localhost:3774')

# Set up OpenTelemetry
resource = Resource.create({
    "service.name": APP_NAME,
})

trace.set_tracer_provider(TracerProvider(resource=resource))

# Configure Watchlog JSON exporter
watchlog_exporter = WatchlogJSONExporter(
    endpoint=f"{WATCHLOG_URL}/apm/{APP_NAME}/v1/traces",
    resource=resource
)

span_processor = BatchSpanProcessor(watchlog_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# FastAPI instrumentation
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
FastAPIInstrumentor.instrument()

# main.py
import otel_config
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "Watchlog APM"}

# Django view - NO manual tracing needed!
def my_view(request):
    # This request is automatically traced by DjangoInstrumentor
    # You'll see a span named "GET /my-view/" in Watchlog
    return JsonResponse({"status": "ok"})

from opentelemetry import trace

tracer = trace.get_tracer(__name__)

def my_function():
    with tracer.start_as_current_span("my_custom_operation") as span:
        span.set_attribute("custom.attribute", "value")
        # Your code here
        pass