Распределенная трассировка в Java с помощью OpenTelemetry

// Создание трассировщика через API
Tracer tracer = GlobalOpenTelemetry.getTracer("my-component");
 
// Создание спана с использованием трассировщика
Span span = tracer.spanBuilder("processOrder")
    .setAttribute("orderId", "12345")
    .startSpan();
 
try (Scope scope = span.makeCurrent()) {
    // Ваш бизнес-код здесь
    processOrderDetails();
} catch (Exception e) {
    span.recordException(e);
    span.setStatus(StatusCode.ERROR, e.getMessage());
    throw e;
} finally {
    span.end(); // Завершение спана
}

// Получение текущего контекста
Context currentContext = Context.current();
 
// Извлечение контекста из HTTP-запроса
Context extractedContext = OpenTelemetry.getPropagators()
    .getTextMapPropagator()
    .extract(currentContext, httpRequest, new HttpHeadersGetter());
 
// Выполнение операции в контексте
try (Scope scope = extractedContext.makeCurrent()) {
    // Операции будут связаны с извлеченным контекстом
}
 
// Внедрение контекста в исходящий запрос
OpenTelemetry.getPropagators()
    .getTextMapPropagator()
    .inject(Context.current(), httpResponse, new HttpHeadersSetter());

// Захват текущего контекста
Context capturedContext = Context.current();
 
executorService.submit(() -> {
    // Восстановление контекста в новом потоке
    try (Scope scope = capturedContext.makeCurrent()) {
        // Код будет выполняться с восстановленным контекстом
        tracer.spanBuilder("asyncOperation").startSpan().end();
    }
});

// Пример с Reactor
Mono.just("data")
    .doOnNext(data -> {
        // Спан будет привязан к правильному родительскому контексту
        tracer.spanBuilder("processData").startSpan().end();
    })
    .subscribe();

Span rootSpan = tracer.spanBuilder("handleRequest")
    .setSpanKind(SpanKind.SERVER)  // Указываем, что это серверный спан
    .startSpan();

Span childSpan = tracer.spanBuilder("validateUser")
    .setParent(Context.current().with(rootSpan))
    .startSpan();

span.setAttribute("user.id", userId);
span.setAttribute("request.size", requestSize);

span.addEvent("cache.check");
span.addEvent("config.loaded", Attributes.of(AttributeKey.stringKey("config.name"), "production"));

span.end();  // Всегда завершайте спаны!

try {
    // Рискованая операция
} catch (Exception e) {
    span.setStatus(StatusCode.ERROR, e.getMessage());
}

SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
    .addSpanProcessor(SimpleSpanProcessor.create(
        new FilteringSpanExporter(spanData -> {
            // Удаляем спаны с чувствительными операциями
            return !spanData.getName().contains("sensitiveOperation");
        }, otherExporter)))
    .build();

public class PrivacyPreservingProcessor implements SpanProcessor {
    @Override
    public void onEnd(ReadableSpan span) {
        SpanData spanData = span.toSpanData();
        // Маскируем персональные данные
        if (spanData.getAttributes().containsKey("user.email")) {
            span.setAttribute("user.email", "*[B]@[/B]*.com");
        }
    }
    // Остальные методы интерфейса
}

JaegerGrpcSpanExporter exporter = JaegerGrpcSpanExporter.builder()
    .setEndpoint("https://jaeger.example.com:14250")
    .addHeader("Authorization", "Bearer " + apiToken)
    .build();

private long addNoise(long originalValue) {
    // Добавляем небольшой шум, следуя распределению Лапласа
    double noise = new Random().nextGaussian() * 5.0; // Смеление до 5 мс
    return originalValue + (long)noise;
}
 
Span span = tracer.spanBuilder("processPayment")
    .setAttribute("duration.ms", addNoise(actualDuration))
    .startSpan();

public class TelemetryConfig {
    
    public static OpenTelemetry initOpenTelemetry() {
        // Создаем OTLP экспортер
        OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("http://localhost:4317")
            .build();
        
        // Настраиваем процессор спанов
        BatchSpanProcessor spanProcessor = BatchSpanProcessor.builder(spanExporter)
            .setScheduleDelay(100, TimeUnit.MILLISECONDS)
            .build();
        
        // Создаем SdkTracerProvider и регистрируем процессор
        SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(spanProcessor)
            .setResource(Resource.getDefault().toBuilder()
                .put(ResourceAttributes.SERVICE_NAME, "my-awesome-service")
                .build())
            .build();
        
        // Создаем и возвращаем глобальный инстанс OpenTelemetry
        return OpenTelemetrySdk.builder()
            .setTracerProvider(sdkTracerProvider)
            .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance()))
            .build();
    }
}

// Получаем трассировщик из глобальной регистрации
Tracer tracer = GlobalOpenTelemetry.get().getTracer("com.example.MyClass");
 
// Создаем спан
Span span = tracer.spanBuilder("doSomethingAwesome")
    .setAttribute("attribute.key", "attribute.value")
    .startSpan();
 
try (Scope ignored = span.makeCurrent()) {
    // Здесь выполняем бизнес-логику
    doBusinessStuff();
} catch (Exception e) {
    span.recordException(e);
    span.setStatus(StatusCode.ERROR, e.getMessage());
    throw e;
} finally {
    // Не забываем закрыть спан!
    span.end();
}

@Configuration
@EnableAutoConfiguration
public class AppConfig {
    
    @Bean
    public WebMvcConfigurer webMvcConfigurer(Tracer tracer) {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                registry.addInterceptor(new TracingHandlerInterceptor(tracer));
            }
        };
    }
}

// Получаем трассировщик
Tracer tracer = GlobalOpenTelemetry.getTracer("business-logic");
 
// Создаём и настраиваем спан
Span processOrderSpan = tracer.spanBuilder("processOrder")
    .setAttribute("order.id", orderId)
    .setAttribute("customer.tier", customerTier)
    .startSpan();
 
// Делаем спан текущим в контексте
try (Scope scope = processOrderSpan.makeCurrent()) {
    // Выполняем бизнес-логику
    validateOrder(order);
    
    // Можно создавать вложенные спаны
    Span childSpan = tracer.spanBuilder("calculateTax")
        .setAttribute("tax.region", taxRegion)
        .startSpan();
    try {
        calculateTax(order);
    } finally {
        childSpan.end();
    }
    
    processPayment(order);
} catch (OrderException e) {
    // Записываем ошибку в спан
    processOrderSpan.recordException(e);
    processOrderSpan.setStatus(StatusCode.ERROR, "Order processing failed: " + e.getMessage());
    throw e;
} finally {
    // Завершаем спан
    processOrderSpan.end();
}

@Service
public class OrderService {
    
    @WithSpan("processOrder")
    public void processOrder(Order order) {
        // Аттрибуты можно добавлять через контекст
        Span.current().setAttribute("order.id", order.getId());
        
        validateOrder(order);
        calculateTax(order);
        processPayment(order);
    }
    
    @WithSpan
    private void validateOrder(Order order) {
        // Имя спана будет соответствовать имени метода
        // ...
    }
    
    @WithSpan("tax.calculation")
    private void calculateTax(Order order) {
        // ...
    }
}

@Aspect
public class TracingAspect {
    
    private final Tracer tracer;
    
    public TracingAspect() {
        this.tracer = GlobalOpenTelemetry.getTracer("aspect-tracer");
    }
    
    @Around("execution(* com.example.service.*.*(..))")
    public Object traceMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String spanName = methodSignature.getDeclaringType().getSimpleName() + "." + methodSignature.getName();
        
        Span span = tracer.spanBuilder(spanName).startSpan();
        try (Scope scope = span.makeCurrent()) {
            addArgumentsAsAttributes(span, methodSignature, joinPoint.getArgs());
            return joinPoint.proceed();
        } catch (Throwable t) {
            span.recordException(t);
            span.setStatus(StatusCode.ERROR);
            throw t;
        } finally {
            span.end();
        }
    }
    
    private void addArgumentsAsAttributes(Span span, MethodSignature signature, Object[] args) {
        Parameter[] parameters = signature.getMethod().getParameters();
        for (int i = 0; i < parameters.length; i++) {
            // Добавляем имена параметров как атрибуты
            span.setAttribute("arg." + parameters[i].getName(), String.valueOf(args[i]));
        }
    }
}

try {
    riskyOperation();
} catch (Exception e) {
    Span.current().recordException(e);
    Span.current().setStatus(StatusCode.ERROR, e.getMessage());
}

public class GlobalExceptionHandler implements Thread.UncaughtExceptionHandler {
    
    @Override
    public void uncaughtException(Thread thread, Throwable throwable) {
        Span span = Span.current();
        if (span != null) {
            span.recordException(throwable);
            span.setStatus(StatusCode.ERROR, throwable.getMessage());
            span.end();
        }
        // Стандартная обработка исключения
    }
}

public class TracedExecutor {
    
    public static <T> T traced(String spanName, Supplier<T> operation) {
        Tracer tracer = GlobalOpenTelemetry.getTracer("traced-executor");
        Span span = tracer.spanBuilder(spanName).startSpan();
        
        try (Scope scope = span.makeCurrent()) {
            return operation.get();
        } catch (Exception e) {
            span.recordException(e);
            span.setStatus(StatusCode.ERROR, e.getMessage());
            throw e;
        } finally {
            span.end();
        }
    }
    
    // Перегрузка для операций без возвращаемого значения
    public static void traced(String spanName, Runnable operation) {
        traced(spanName, () -> {
            operation.run();
            return null;
        });
    }
}

public void processOrder(Order order) {
    TracedExecutor.traced("processOrder", () -> {
        validateOrder(order);
        calculateTax(order);
        return processPayment(order);
    });
}

# Имя сервиса
otel.service.name=order-processor
# Endpoint для отправки трейсов
otel.exporter.otlp.endpoint=http://collector:4317
# Интервал отправки трейсов
otel.bsp.schedule.delay=5000

@Component
public class OpenTelemetryHandlerInterceptor implements HandlerInterceptor {
    
    private final Tracer tracer;
    
    public OpenTelemetryHandlerInterceptor(Tracer tracer) {
        this.tracer = tracer;
    }
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Span.current().setAttribute("controller.class", 
                    handlerMethod.getBeanType().getSimpleName());
            Span.current().setAttribute("controller.method", 
                    handlerMethod.getMethod().getName());
        }
        return true;
    }
}
 
@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    private final OpenTelemetryHandlerInterceptor interceptor;
    
    public WebConfig(OpenTelemetryHandlerInterceptor interceptor) {
        this.interceptor = interceptor;
    }
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(interceptor);
    }
}

@SpringBootTest
@AutoConfigureObservability 
public class OrderProcessingIntegrationTest {
 
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private SdkMeterProvider meterProvider;
    
    @Autowired
    private SdkTracerProvider tracerProvider;
    
    @Test
    public void testOrderProcessing() {
        // Настраиваем экспортер для тестов
        InMemorySpanExporter spanExporter = InMemorySpanExporter.create();
        tracerProvider.addSpanProcessor(SimpleSpanProcessor.create(spanExporter));
        
        // Выполняем операцию
        orderService.processOrder(new Order("12345"));
        
        // Проверяем, что все трейсы корректны
        List<SpanData> spans = spanExporter.getFinishedSpanItems();
        
        // Ищем нужные спаны
        Optional<SpanData> processOrderSpan = spans.stream()
                .filter(span -> span.getName().equals("processOrder"))
                .findFirst();
        
        // Проверка атрибутов
        assertTrue(processOrderSpan.isPresent());
        assertEquals("12345", 
                processOrderSpan.get().getAttributes().get(AttributeKey.stringKey("order.id")));
        
        // Проверяем последовательность операций
        assertOperationSequence(spans, 
                "processOrder", "validateOrder", "calculateTax", "processPayment");
    }
    
    // Вспомогательный метод для проверки последовательности операций
    private void assertOperationSequence(List<SpanData> spans, String... operations) {
        // Реализация проверки последовательности спанов
    }
}

// Получаем метер
Meter meter = GlobalOpenTelemetry.getMeter("request-metrics");
 
// Создаём счётчик
LongCounter requestCounter = meter.counterBuilder("requests")
    .setDescription("Количество входящих запросов")
    .setUnit("1")
    .build();
 
// Инкрементируем счётчик с атрибутами
requestCounter.add(1, Attributes.of(
    AttributeKey.stringKey("endpoint"), "/api/orders",
    AttributeKey.stringKey("method"), "POST"
));

// Создаём гистограмму для отслеживания времени выполнения
LongHistogram latencyHistogram = meter.histogramBuilder("operation.latency")
    .setDescription("Время выполнения операции")
    .setUnit("ms")
    .build();
 
// В обработчике запроса
long startTime = System.currentTimeMillis();
try {
    processRequest();
} finally {
    long latency = System.currentTimeMillis() - startTime;
    // Записываем метрику и связываем с текущим трейсом
    latencyHistogram.record(latency, Attributes.of(
        AttributeKey.stringKey("trace.id"), Span.current().getSpanContext().getTraceId(),
        AttributeKey.stringKey("operation"), "processRequest"
    ));
}

// Кастомный аппендер, добавляющий трейс-идентификаторы в логи
public class OpenTelemetryLogAppender extends AppenderBase<ILoggingEvent> {
    @Override
    protected void append(ILoggingEvent event) {
        SpanContext spanContext = Span.current().getSpanContext();
        if (spanContext.isValid()) {
            MDC.put("trace_id", spanContext.getTraceId());
            MDC.put("span_id", spanContext.getSpanId());
        }
        // продолжаем обработку события логирования
    }
}

JaegerGrpcSpanExporter jaegerExporter = JaegerGrpcSpanExporter.builder()
    .setEndpoint("http://jaeger:14250")
    .build();
 
// Добавляем в провайдер
SdkTracerProvider.builder()
    .addSpanProcessor(BatchSpanProcessor.builder(jaegerExporter).build())
    .build();

PrometheusHttpServer prometheusServer = PrometheusHttpServer.builder()
    .setPort(9464)
    .build();
 
// Регистрируем экспортер
SdkMeterProvider.builder()
    .registerMetricReader(prometheusServer)
    .build();

ZipkinSpanExporter zipkinExporter = ZipkinSpanExporter.builder()
    .setEndpoint("http://zipkin:9411/api/v2/spans")
    .build();
 
// Добавляем в провайдер
SdkTracerProvider.builder()
    .addSpanProcessor(BatchSpanProcessor.builder(zipkinExporter).build())
    .build();

// Кастомный экспортер для Elastic APM
public class ElasticApmExporter implements SpanExporter {
    private final ApmClient apmClient;
    
    @Override
    public CompletableResultCode export(Collection<SpanData> spans) {
        spans.forEach(spanData -> {
            Transaction transaction = apmClient.startTransaction()
                .setName(spanData.getName())
                .setType(spanData.getKind().toString());
            
            // Копируем атрибуты
            spanData.getAttributes().forEach((key, value) -> 
                transaction.addLabel(key.getKey(), value.toString()));
            
            // Устанавливаем время
            transaction.setStartTimestamp(spanData.getStartEpochNanos() / 1_000_000);
            transaction.setEndTimestamp(
                (spanData.getStartEpochNanos() + spanData.getEndEpochNanos()) / 1_000_000);
            
            transaction.end();
        });
        
        return CompletableResultCode.ofSuccess();
    }
    
    @Override
    public CompletableResultCode flush() {
        return CompletableResultCode.ofSuccess();
    }
    
    @Override
    public CompletableResultCode shutdown() {
        apmClient.close();
        return CompletableResultCode.ofSuccess();
    }
}

// Interceptor для связывания трейсов с логами
public class TracingMdcInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        SpanContext context = Span.current().getSpanContext();
        if (context.isValid()) {
            MDC.put("trace_id", context.getTraceId());
            MDC.put("span_id", context.getSpanId());
        }
        return true;
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
                                Object handler, Exception ex) {
        MDC.remove("trace_id");
        MDC.remove("span_id");
    }
}

SamplerBuilder builder = Sampler.parentBased(
    Sampler.traceIdRatioBased(0.1) // Сохраняем 10% трейсов
);
 
SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
    .setSampler(builder.build())
    .build();

public class AdaptiveSampler implements Sampler {
    private final AtomicDouble samplingRate = new AtomicDouble(1.0);
    private final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
    
    public AdaptiveSampler(MetricReader metricReader) {
        executor.scheduleAtFixedRate(() -> {
            // Получаем текущую нагрузку на систему
            double currentLoad = getCurrentSystemLoad();
            
            // Корректируем частоту семплирования
            if (currentLoad > 0.8) { // Высокая нагрузка
                samplingRate.set(0.01); // Семплируем только 1%
            } else if (currentLoad > 0.5) { // Средняя нагрузка
                samplingRate.set(0.1); // Семплируем 10%
            } else { // Низкая нагрузка
                samplingRate.set(0.5); // Семплируем 50%
            }
        }, 0, 1, TimeUnit.MINUTES);
    }
    
    @Override
    public SamplingResult shouldSample(/*параметры*/) {
        // Реализация решения о семплировании
        return new SamplingResult() {/*...*/};
    }
}

public class AttributeBasedSampler implements Sampler {
    private final Set<String> importantEndpoints = Set.of("/api/critical", "/api/orders");
    
    @Override
    public SamplingResult shouldSample(
            Context parentContext,
            String traceId,
            String name,
            SpanKind spanKind,
            Attributes attributes,
            List<SpanLink> parentLinks) {
        
        // Всегда семплируем важные эндпоинты
        String endpoint = attributes.get(AttributeKeys.HTTP_URL);
        if (endpoint != null && importantEndpoints.contains(endpoint)) {
            return SamplingResult.recordAndSample();
        }
        
        // Для остальных используем вероятностное семплирование
        return Sampler.traceIdRatioBased(0.01).shouldSample(
            parentContext, traceId, name, spanKind, attributes, parentLinks);
    }
}

public class EnrichmentSpanProcessor implements SpanProcessor {
    private final Map<String, String> additionalAttributes;
    
    public EnrichmentSpanProcessor(Map<String, String> additionalAttributes) {
        this.additionalAttributes = additionalAttributes;
    }
    
    @Override
    public void onStart(Context parentContext, ReadWriteSpan span) {
        // Добавляем дополнительные атрибуты к каждому спану
        additionalAttributes.forEach((key, value) -> 
            span.setAttribute(key, value));
        
        // Можно добавить динамические атрибуты
        span.setAttribute("host.name", getHostName());
        span.setAttribute("app.version", getAppVersion());
    }
    
    @Override
    public void onEnd(ReadableSpan span) {
        // Можно выполнить действия при завершении спана
    }
    
    @Override
    public CompletableResultCode shutdown() {
        return CompletableResultCode.ofSuccess();
    }
    
    @Override
    public CompletableResultCode forceFlush() {
        return CompletableResultCode.ofSuccess();
    }
}

public class CustomDbExporter implements SpanExporter {
    private final JdbcTemplate jdbcTemplate;
    
    @Override
    public CompletableResultCode export(Collection<SpanData> spans) {
        spans.forEach(span -> {
            jdbcTemplate.update(
                "INSERT INTO spans (trace_id, span_id, name, start_time, end_time) VALUES (?, ?, ?, ?, ?)",
                span.getTraceId(),
                span.getSpanId(),
                span.getName(),
                span.getStartEpochNanos(),
                span.getEndEpochNanos()
            );
            
            // Сохраняем атрибуты
            span.getAttributes().forEach((key, value) -> 
                jdbcTemplate.update(
                    "INSERT INTO span_attributes (span_id, key, value) VALUES (?, ?, ?)",
                    span.getSpanId(),
                    key.getKey(),
                    value.toString()
                ));
        });
        
        return CompletableResultCode.ofSuccess();
    }
}

OrderService.createOrder [200ms]
  └── InventoryService.checkAvailability [15ms]
  └── PaymentService.processPayment [180ms]
      └── ThirdPartyPaymentGateway.charge [175ms]
          └── HTTP POST https://payment.example.com/api/charges [172ms, ERROR]
  └── NotificationService.sendConfirmation [5ms]

// До оптимизации - множественные запросы к БД
@WithSpan
public List<Product> getRecommendations(String userId) {
  User user = userRepository.findById(userId); // 50ms
  List<Order> orders = orderRepository.findByUserId(userId); // 120ms
  List<Product> viewed = productRepository.findViewedByUserId(userId); // 80ms
  // ...анализ и фильтрация...
  return recommendations;
}

@WithSpan
public List<Product> getRecommendations(String userId) {
  // Параллельное выполнение запросов
  CompletableFuture<User> userFuture = 
      CompletableFuture.supplyAsync(() -> userRepository.findById(userId));
  CompletableFuture<List<Order>> ordersFuture = 
      CompletableFuture.supplyAsync(() -> orderRepository.findByUserId(userId));
  CompletableFuture<List<Product>> viewedFuture = 
      CompletableFuture.supplyAsync(() -> productRepository.findViewedByUserId(userId));
  
  // Ожидание всех результатов
  CompletableFuture.allOf(userFuture, ordersFuture, viewedFuture).join();
  
  // ...анализ и фильтрация с полученными данными...
  return recommendations;
}

// В коде приложения
@PostConstruct
public void registerDeploymentMarker() {
    Span span = tracer.spanBuilder("deployment-marker")
        .setAttribute("deployment.version", appVersion)
        .setAttribute("deployment.environment", environment)
        .setAttribute("deployment.timestamp", System.currentTimeMillis())
        .startSpan();
    span.end();
}

public class AnomalyDetector {
    
    private final TracesAnalyticsService analyticsService;
    private final AlertingService alertingService;
    
    @Scheduled(fixedRate = 60000)  // Каждую минуту
    public void detectAnomalies() {
        Map<String, OperationStats> stats = analyticsService.getOperationsStats(Duration.ofMinutes(5));
        
        // Для каждой операции проверяем отклонение от нормы
        stats.forEach((operation, stats) -> {
            double avgLatency = stats.getAvgLatency();
            double p95Latency = stats.getP95Latency();
            double errorRate = stats.getErrorRate();
            
            // Если p95 превышает среднее более чем в 3 раза
            if (p95Latency > avgLatency * 3) {
                alertingService.sendAlert(
                    AlertLevel.WARNING,
                    "Performance degradation detected in " + operation,
                    Map.of("p95", p95Latency, "avg", avgLatency)
                );
            }
        });
    }
}

// Добавляйте ручную инструментацию в стратегически важных местах
@WithSpan("критическая-бизнес-операция")
public void processBusinessTransaction(Transaction tx) {
    Span span = Span.current();
    span.setAttribute("transaction.id", tx.getId());
    span.setAttribute("transaction.amount", tx.getAmount());
    
    // Остальной код без изменений
}

// Пример из внутренней документации
public class TracingPatterns {
    // ТАК ДЕЛАТЬ - информативное имя и атрибуты
    @WithSpan("user.verification")
    void verifyUserCorrect(User user) {
        Span.current().setAttribute("user.type", user.getType().toString());
    }
    
    // ТАК НЕ ДЕЛАТЬ - малоинформативный спан
    @WithSpan
    void verifBad(User u) {
        // Без атрибутов
    }
}

// Адаптер для интеграции MDC с OpenTelemetry
public class LoggingMdcSpanExporter implements SpanExporter {
    @Override
    public CompletableResultCode export(Collection<SpanData> spans) {
        spans.forEach(span -> {
            // Отправляем в Elasticsearch с трейс-контекстом
            Map<String, Object> doc = new HashMap<>();
            doc.put("trace_id", span.getTraceId());
            doc.put("span_id", span.getSpanId());
            doc.put("name", span.getName());
            // ... другие поля ...
            
            elasticsearchClient.index(doc);
        });
        return CompletableResultCode.ofSuccess();
    }
}

@Aspect
@Component
public class LegacySystemTracer {
    private final Tracer tracer;
    
    @Around("execution(* com.legacy.system.*.process*(..))")
    public Object traceProcessing(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getSignature().getDeclaringTypeName();
        
        Span span = tracer.spanBuilder(className + "." + methodName).startSpan();
        try (Scope scope = span.makeCurrent()) {
            return joinPoint.proceed();
        } catch (Exception e) {
            span.recordException(e);
            span.setStatus(StatusCode.ERROR);
            throw e;
        } finally {
            span.end();
        }
    }
}

// Spring Boot auto-configuration
@Configuration
@ConditionalOnProperty(value = "telemetry.enabled", havingValue = "true")
public class TelemetryAutoConfig {
    
    @Bean
    public WebMvcConfigurer tracingWebMvcConfigurer(Tracer tracer) {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                registry.addInterceptor(new TracingHandlerInterceptor(tracer));
            }
        };
    }
    
    // Другие бины для конфигурации трассировки
}

@Component
public class TelemetryStatusCollector {
    @Scheduled(fixedRate = 300000) // Каждые 5 минут
    public void collectTelemetryStatus() {
        int totalEndpoints = endpointRegistry.getTotal();
        int instrumentedEndpoints = endpointRegistry.getInstrumented();
        
        double coverage = (double) instrumentedEndpoints / totalEndpoints * 100;
        
        instrumentationCoverageGauge.update(coverage);
    }
}

public class PredictiveAnomalyDetector {
    private final MLModel performanceModel;
    
    public void analyzeTraces(List<SpanData> recentTraces) {
        // Извлекаем признаки для модели
        List<FeatureVector> features = extractFeatures(recentTraces);
        
        // Получаем предсказание проблем
        List<AnomalyPrediction> predictions = performanceModel.predict(features);
        
        // Генерируем предупреждения для DevOps команды
        predictions.stream()
            .filter(p -> p.getProbability() > 0.7)
            .forEach(this::sendAlert);
    }
}

// Интеграция профилирования с трассировкой
Span span = tracer.spanBuilder("computeRecommendations").startSpan();
try (Scope scope = span.makeCurrent()) {
    // Включаем профилирование для этой операции
    Profiler profiler = ProfilingSystem.startProfiling();
    
    // Выполняем операцию
    List<Product> recommendations = computeExpensiveRecommendations(userId);
    
    // Завершаем профилирование и прикрепляем результаты к спану
    ProfilingSnapshot snapshot = profiler.stopAndCollect();
    
    // Добавляем ссылку на профиль в спан
    span.setAttribute("profiling.snapshot_id", snapshot.getId());
    
    return recommendations;
} finally {
    span.end();
}

// Конфигурация непрерывного профилирования с OpenTelemetry
SdkBuilder sdkBuilder = OpenTelemetrySdk.builder()
    .setTracerProvider(tracerProvider)
    .setMeterProvider(meterProvider);
 
// Добавляем профилирование, если поддерживается
if (ContinuousProfilingFacade.isSupported()) {
    sdkBuilder.addProfilingDataSource(
        ContinuousProfilingFacade.createCpuProfiler(
            ProfilingConfig.builder()
                .setSamplingIntervalMs(10)
                .setBufferSizeBytes(1024 * 1024)
                .build()
        )
    );
}
 
OpenTelemetry openTelemetry = sdkBuilder.build();

// Высокоуровневая интеграция с eBPF-трассировкой
@Configuration
public class EbpfTracingConfig {
    @Bean
    public EbpfTracer ebpfTracer() {
        return EbpfTracer.builder()
            .enableJvmCalls(true)
            .enableNetworkIo(true)
            .enableFileIo(true)
            .samplingRate(0.1)  // 10% от событий
            .build();
    }
    
    @Bean
    public EbpfOpenTelemetryBridge ebpfBridge(EbpfTracer tracer, OpenTelemetry openTelemetry) {
        return new EbpfOpenTelemetryBridge(tracer, openTelemetry);
    }
}