import logging
from flask import Flask, request, g
import time

class ObservabilityMiddleware:
    def __init__(self, app):
        self.app = app
        self.logger = logging.getLogger('microservice.observability')

    def __call__(self, environ, start_response):
        start_time = time.time()
        request_id = self._generate_request_id()

        # 注入请求上下文
        g.request_id = request_id
        g.start_time = start_time

        # 记录请求开始日志
        self.logger.info({
            'event': 'request_start',
            'request_id': request_id,
            'method': environ['REQUEST_METHOD'],
            'path': environ['PATH_INFO'],
            'timestamp': start_time
        })

        def custom_start_response(status, headers, exc_info=None):
            # 计算处理时间
            processing_time = time.time() - start_time

            # 记录响应日志
            self.logger.info({
                'event': 'request_end',
                'request_id': request_id,
                'status': status.split()[0],
                'processing_time': processing_time,
                'timestamp': time.time()
            })

            return start_response(status, headers, exc_info)

        return self.app(environ, custom_start_response)

    def _generate_request_id(self):
        import uuid
        return str(uuid.uuid4())

app = Flask(__name__)
app.wsgi_app = ObservabilityMiddleware(app.wsgi_app)

// Counter实现的核心数据结构
public class DefaultCounter implements Counter {
    private final AtomicDouble count;
    private final Meter.Id id;

    @Override
    public void increment(double amount) {
        if (amount > 0) {
            // 使用CAS操作保证原子性
            double current, newValue;
            do {
                current = count.get();
                newValue = current + amount;
            } while (!count.compareAndSet(current, newValue));

            // 发布指标更新事件
            publishMetricsEvent(new CounterIncrementEvent(id, amount));
        }
    }

    // 内存布局优化：避免伪共享
    @Contended
    private static class AtomicDouble extends AtomicLong {
        private static final long serialVersionUID = 1L;

        public double get() {
            return Double.longBitsToDouble(get());
        }

        public boolean compareAndSet(double expect, double update) {
            return compareAndSet(
                Double.doubleToRawLongBits(expect),
                Double.doubleToRawLongBits(update)
            );
        }
    }
}

const { v4: uuidv4 } = require('uuid');

class TracingMiddleware {
    constructor() {
        this.tracer = new OpenTracingTracer();
    }

    middleware() {
        return (req, res, next) => {
            // 提取或生成Trace上下文

            const spanContext = this.extractSpanContext(req) || 
                               this.createRootSpanContext();

            // 创建请求Span
            const span = this.tracer.startSpan('http_request', {
                childOf: spanContext,
                tags: {
                    'http.method': req.method,
                    'http.url': req.url,
                    'span.kind': 'server'
                }
            });

            // 注入Span到请求上下文
            req.span = span;

            // 响应拦截器
            const originalSend = res.send;
            res.send = function(data) {
                // 记录响应信息
                span.setTag('http.status_code', res.statusCode);
                if (res.statusCode >= 400) {
                    span.setTag('error', true);
                }

                span.finish();
                originalSend.call(this, data);
            };

            next();
        };
    }

    extractSpanContext(req) {
        // 从HTTP头提取分布式追踪上下文
        const traceId = req.headers['x-trace-id'];
        const spanId = req.headers['x-span-id'];

        if (traceId && spanId) {
            return { traceId, spanId };
        }
        return null;
    }

    createRootSpanContext() {
        return {
            traceId: uuidv4(),
            spanId: uuidv4()
        };
    }
}

// Span类的核心设计
class Span {
    constructor(tracer, operationName, options) {
        this.tracer = tracer;
        this.operationName = operationName;

        this.context = options.context || this._createContext();
        this.startTime = process.hrtime();
        this.tags = new Map();
        this.logs = [];
        this._isFinished = false;
    }

    setTag(key, value) {
        if (this._isFinished) {
            throw new Error('Cannot set tag on finished span');
        }
        this.tags.set(key, value);
        return this;
    }

    log(fields) {
        this.logs.push({
            timestamp: Date.now(),
            fields: fields
        });
        return this;
    }

    finish(finishTime) {
        if (this._isFinished) {
            return;
        }

        this._isFinished = true;

        const endTime = finishTime || process.hrtime();
        const duration = this._calculateDuration(this.startTime, endTime);

        // 发布Span完成事件
        this.tracer.reportSpan({
            context: this.context,
            operationName: this.operationName,
            startTime: this.startTime,
            duration: duration,
            tags: Object.fromEntries(this.tags),
            logs: this.logs
        });
    }

    _calculateDuration(start, end) {
        const NS_PER_SEC = 1e9;
        const diff = (end[0] - start[0]) * NS_PER_SEC + (end[1] - start[1]);
        return diff / 1e6; // 转换为毫秒
    }
}

# observability_config.py
import logging
from logging.handlers import RotatingFileHandler
import os

class ObservabilityConfig:
    # 日志配置
    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    LOG_MAX_BYTES = 100 * 1024 * 1024  # 100MB
    LOG_BACKUP_COUNT = 10

    # 指标配置
    METRICS_ENABLED = True
    METRICS_PORT = 9090
    METRICS_PATH = '/metrics'

    # 追踪配置
    TRACING_ENABLED = True
    TRACING_SAMPLE_RATE = 0.1  # 10%采样率
    TRACING_EXPORTER = os.getenv('TRACING_EXPORTER', 'jaeger')

    @classmethod
    def setup_logging(cls):
        logger = logging.getLogger()
        logger.setLevel(getattr(logging, cls.LOG_LEVEL))

        # 文件处理器
        file_handler = RotatingFileHandler(
            'app.log',
            maxBytes=cls.LOG_MAX_BYTES,
            backupCount=cls.LOG_BACKUP_COUNT
        )
        file_handler.setFormatter(logging.Formatter(cls.LOG_FORMAT))
        logger.addHandler(file_handler)

        # 控制台处理器（开发环境）
        if os.getenv('ENVIRONMENT') == 'development':
            console_handler = logging.StreamHandler()
            console_handler.setFormatter(logging.Formatter(cls.LOG_FORMAT))
            logger.addHandler(console_handler)

# application-observability.yml
management:
  endpoints:
    web:
      exposure:
        include: "health,metrics,prometheus"
  endpoint:
    metrics:
      enabled: true
    prometheus:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
    distribution:
      percentiles-histogram:
        http.server.requests: true

logging:
  pattern:
    level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"
  level:
    org.springframework.web: INFO
    com.example: DEBUG

spring:
  sleuth:
    enabled: true
    sampler:
      probability: 0.1
  zipkin:
    base-url: http://zipkin:9411/

# blog_observability.py
from prometheus_client import Counter, Histogram, generate_latest
from flask import request, Response
import time

# 定义指标
REQUEST_COUNT = Counter('blog_requests_total', 
                       'Total HTTP Requests', 
                       ['method', 'endpoint', 'status'])
REQUEST_DURATION = Histogram('blog_request_duration_seconds',
                           'HTTP Request duration')

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype='text/plain')

@app.before_request
def before_request():
    request.start_time = time.time()

@app.after_request
def after_request(response):
    # 记录请求指标
    request_latency = time.time() - request.start_time
    REQUEST_DURATION.observe(request_latency)
    REQUEST_COUNT.labels(
        method=request.method,
        endpoint=request.endpoint,
        status=response.status_code
    ).inc()

    return response

class AIModelObservability:
    def __init__(self, model_name):
        self.model_name = model_name
        self.metrics = {
            'inference_latency': Histogram(
                'ai_model_inference_latency_seconds',
                'Model inference latency',
                ['model_name', 'status']
            ),
            'prediction_quality': Gauge(
                'ai_model_prediction_quality',
                'Prediction quality score',
                ['model_name']
            )
        }

    def record_inference(self, features, prediction, latency, actual=None):
        # 记录推理延迟
        self.metrics['inference_latency'].labels(
            model_name=self.model_name,
            status='success'
        ).observe(latency)

        # 计算预测质量（如果有真实值）
        if actual is not None:
            quality = self._calculate_quality(prediction, actual)
            self.metrics['prediction_quality'].labels(
                model_name=self.model_name
            ).set(quality)