Feature Flags, System Monitoring, and Developer Experience — Cheat Sheet¶

# pip install opentelemetry-sdk opentelemetry-exporter-otlp

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.sdk.resources import Resource

# Configure the tracer provider with service metadata
resource = Resource.create({"service.name": "my-service", "service.version": "1.0.0"})
provider = TracerProvider(resource=resource)

# Configure OTLP exporter (sends to OTel Collector or Jaeger)
exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
provider.add_span_processor(BatchSpanProcessor(exporter))

# Set the global tracer provider
trace.set_tracer_provider(provider)
tracer = trace.get_tracer(__name__)

# Create spans in your code
with tracer.start_as_current_span("operation-name") as span:
    span.set_attribute("user.id", "123")    # Add custom attributes
    span.set_attribute("http.method", "GET")
    # ... do work here

# pip install opentelemetry-instrumentation-flask

from opentelemetry.instrumentation.flask import FlaskInstrumentor
from flask import Flask

app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)  # Automatically traces all Flask routes

from prometheus_client import Counter, Gauge, Histogram, start_http_server

# Counter — use .inc() or .inc(amount)
REQUESTS = Counter('http_requests_total', 'Total HTTP requests',
                   ['method', 'endpoint', 'status'])
REQUESTS.labels(method='GET', endpoint='/api/users', status='200').inc()

# Gauge — use .set(), .inc(), .dec()
ACTIVE_CONNECTIONS = Gauge('active_connections', 'Number of active connections')
ACTIVE_CONNECTIONS.set(42)
ACTIVE_CONNECTIONS.inc()
ACTIVE_CONNECTIONS.dec()

# Histogram — use .observe(value)
REQUEST_LATENCY = Histogram('http_request_duration_seconds',
                            'HTTP request latency',
                            ['endpoint'],
                            buckets=[0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0])
REQUEST_LATENCY.labels(endpoint='/api/users').observe(0.042)

# Start the metrics server (exposes /metrics endpoint)
start_http_server(8000)

import posthog

posthog.api_key = 'your-api-key'
posthog.host = 'https://app.posthog.com'  # or your self-hosted URL

# Boolean flag
if posthog.feature_enabled('new-checkout-flow', 'user-123'):
    show_new_checkout()
else:
    show_old_checkout()

# Multivariate flag (returns string variant or None)
variant = posthog.get_feature_flag('checkout-experiment', 'user-123')
if variant == 'variant-a':
    show_variant_a()
elif variant == 'variant-b':
    show_variant_b()
else:
    show_control()

import os
import json
from functools import wraps

# Read flags from environment variable or file
def get_flags():
    flags_json = os.getenv('FEATURE_FLAGS', '{}')
    return json.loads(flags_json)

def feature_flag(flag_name, default=False):
    """Decorator that wraps a function with a feature flag check."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            if get_flags().get(flag_name, default):
                return func(*args, **kwargs)
            # Return None or a fallback when flag is off
        return wrapper
    return decorator

# Usage: FEATURE_FLAGS='{"new_algo": true}' python app.py
@feature_flag('new_algo')
def run_new_algorithm(data):
    return process_with_new_algo(data)

# pip install sentry-sdk

import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration

sentry_sdk.init(
    dsn="https://your-dsn@o123456.ingest.sentry.io/7890",
    integrations=[FlaskIntegration()],  # Auto-capture Flask errors
    traces_sample_rate=0.1,             # 10% of transactions for performance
    environment="production",
    release="my-app@1.2.3",            # Link errors to releases
)

# Manual error capture
try:
    risky_operation()
except ValueError as e:
    sentry_sdk.capture_exception(e)

# Add context to errors
with sentry_sdk.push_scope() as scope:
    scope.set_tag("payment.provider", "stripe")
    scope.set_user({"id": "user-123", "email": "user@example.com"})
    sentry_sdk.capture_message("Payment failed", level="error")

# pip install posthog

import posthog

posthog.api_key = 'phc_your_api_key'
posthog.host = 'https://app.posthog.com'

# Track an event
posthog.capture(
    distinct_id='user-123',
    event='checkout_completed',
    properties={
        'order_value': 49.99,
        'items_count': 3,
        'payment_method': 'card',
    }
)

# Identify a user (set person properties)
posthog.identify(
    distinct_id='user-123',
    properties={
        'email': 'user@example.com',
        'plan': 'pro',
        'created_at': '2025-01-15',
    }
)

# Feature flag check with automatic event tracking
if posthog.feature_enabled('new-dashboard', 'user-123'):
    render_new_dashboard()