Advanced Tracing (OTEL)

import asyncio
from opentelemetry import trace
from opentelemetry.context import attach, detach, get_current

tracer = trace.get_tracer(__name__)

async def async_func(ctx):
    token = attach(ctx)
    try:
        current_span = trace.get_current_span()
        current_span.set_attribute("input.value", "User Input") # Corrected attribute key
        await asyncio.sleep(1)  # Simulate async work
    finally:
        detach(token)

def sync_func():
    with tracer.start_as_current_span("sync_span") as span:
        # Capture the current context
        context = get_current()
        # Run the async function, passing the context
        asyncio.run(async_func(context))

if __name__ == "__main__":
    sync_func()

import { trace, context, Context } from "@opentelemetry/api";
import { promisify } from "util";

const sleep = promisify(setTimeout);
const tracer = trace.getTracer("my-app-tracer");

async function asyncFunc(ctx: Context): Promise<void> {
    // context.with ensures the passed context is active within this function's scope.
    await context.with(ctx, async () => {
        const currentSpan = trace.getSpan(context.active());
        if (currentSpan) {
            currentSpan.setAttribute("input.value", "User Input from TS");
        }
        await sleep(1000); // Simulate async work
    });
}

async function syncFunc(): Promise<void> {
    // Start a parent span
    await tracer.startActiveSpan("sync_span", async (span) => {
        // Capture the current context (which includes sync_span)
        const currentActiveContext = context.active();
        // Run the async function, passing the captured context
        await asyncFunc(currentActiveContext);
        span.end();
    });
}

// To run the example:
// syncFunc().then(() => console.log("Trace example completed."));

import requests
from opentelemetry import trace
# from opentelemetry.context import Context # Not strictly needed for inject but good for awareness
from opentelemetry.propagators.textmap import DefaultTextMapPropagator

tracer = trace.get_tracer(__name__)

def make_request_to_service_b():
    # Start a new span for this operation
    with tracer.start_as_current_span("llm_service_a") as span:
        # Prepare headers
        headers = {}
        DefaultTextMapPropagator().inject(carrier=headers)  # Inject the current context

        # Make the request with the injected headers
        response = requests.get("http://localhost:5001/endpoint", headers=headers) # Assuming Python Service B runs on 5001
        return response.text

# Example usage (ensure Service B is running and OTel SDK is configured for console output):
# if __name__ == "__main__":
#     from opentelemetry.sdk.trace import TracerProvider
#     from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
#     trace.set_tracer_provider(TracerProvider())
#     trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
#     print(make_request_to_service_b())

import { trace, context, propagation, SpanStatusCode } from "@opentelemetry/api";
import { HttpTraceContextPropagator } from "@opentelemetry/core";
import fetch from "node-fetch"; // yarn add node-fetch @types/node-fetch

const tracer = trace.getTracer("my-service-a-tracer");

// It's common to set this globally once for an application.
propagation.setGlobalPropagator(new HttpTraceContextPropagator());

async function makeRequestToServiceB(): Promise<string> {
    return await tracer.startActiveSpan("typescript_llm_service_a", async (span) => {
        const headers: Record<string, string> = {};
        propagation.inject(context.active(), headers);

        try {
            const response = await fetch("http://localhost:5002/ts-endpoint", { headers }); // Assuming TS Service B on 5002
            if (!response.ok) {
                span.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP error! status: ${response.status}` });
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            const data = await response.text();
            span.setStatus({ code: SpanStatusCode.OK });
            return data;
        } catch (error) {
            span.recordException(error as Error);
            span.setStatus({ code: SpanStatusCode.ERROR, message: (error as Error).message });
            throw error;
        } finally {
            span.end();
        }
    });
}

// Example usage (ensure Service B is running and OTel SDK is configured):
// async function main() {
//     // Minimal OTel SDK setup for console output
//     const { NodeTracerProvider } = await import('@opentelemetry/sdk-trace-node');
//     const { ConsoleSpanExporter, SimpleSpanProcessor } = await import('@opentelemetry/sdk-trace-base');
//     const provider = new NodeTracerProvider();
//     provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
//     provider.register();
//     try {
//         const response = await makeRequestToServiceB();
//         console.log("Response from Service B:", response);
//     } catch (err) {
//         console.error("Error making request:", err);
//     }
// }
// main();

from flask import Flask, request
from opentelemetry import trace
from opentelemetry.propagators.textmap import DefaultTextMapPropagator
# Minimal OTel setup for console output if not already configured globally
# from opentelemetry.sdk.trace import TracerProvider
# from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
# trace.set_tracer_provider(TracerProvider())
# trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))

app = Flask(__name__)
tracer = trace.get_tracer("my-service-b-tracer") # Corrected tracer name from __name__ for clarity

@app.route("/endpoint")
def endpoint():
    # Extract the context from incoming request
    context_from_propagator = DefaultTextMapPropagator().extract(carrier=dict(request.headers))

    # Create a new span as child
    with tracer.start_as_current_span("python_service_b_processing", context=context_from_propagator) as span:
        span.add_event("Received request in Python Service B")
        # ... do some processing ...
        return "Hello from Python Service B"

# if __name__ == "__main__":
#     app.run(port=5001) # Assuming Python Service B runs on 5001

import { trace, context, propagation, SpanStatusCode } from "@opentelemetry/api";
import { HttpTraceContextPropagator } from "@opentelemetry/core";
import express, { Request, Response } from 'express'; // yarn add express @types/express

const tracer = trace.getTracer("my-ts-service-b-tracer");

// Ensure the same propagator is used as in Service A.
// If not set globally in Service A, ensure it's configured here or use a globally set one.
// propagation.setGlobalPropagator(new HttpTraceContextPropagator()); // Usually set globally once.

const app = express();
const port = 5002; // Assuming TS Service B runs on 5002

app.get('/ts-endpoint', (req: Request, res: Response) => {
    const parentContext = propagation.extract(context.active(), req.headers);

    tracer.startActiveSpan("typescript_service_b_processing", { context: parentContext }, (span) => {
        try {
            span.addEvent("Received request in Typescript Service B");
            // ... do some processing ...
            res.send("Hello from Typescript Service B");
            span.setStatus({ code: SpanStatusCode.OK });
        } catch (error) {
            span.recordException(error as Error);
            span.setStatus({ code: SpanStatusCode.ERROR, message: (error as Error).message });
            res.status(500).send("Error processing request");
        } finally {
            span.end();
        }
    });
});

// Example OTel SDK setup for console output before starting server:
// async function startServer() {
//     // Minimal OTel SDK setup for console output
//     const { NodeTracerProvider } = await import('@opentelemetry/sdk-trace-node');
//     const { ConsoleSpanExporter, SimpleSpanProcessor } = await import('@opentelemetry/sdk-trace-base');
//     const provider = new NodeTracerProvider();
//     provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
//     provider.register();

//     app.listen(port, () => {
//         console.log(`Typescript Service B listening on http://localhost:${port}`);
//     });
// }
// startServer();

import concurrent.futures
from opentelemetry import trace
from opentelemetry.context import attach, detach, get_current
from typing import Callable # Added for type hint

tracer = trace.get_tracer(__name__)

def func1():
    # Some example work done in a thread.
    current_span = trace.get_current_span()
    current_span.set_attribute("input.value", "User Input from func1") # Corrected attribute value
    return "func1 result"

def func2():
    # Another example function that logs an event to the current span.
    current_span = trace.get_current_span()
    current_span.set_attribute("input.value", "User Input from func2") # Corrected attribute value
    return "func2 result"

def wrapped_func(func: Callable, main_context):
    # Wraps the original function to attach/detach the captured context
    # so the worker thread has the correct span context.
    def wrapper():
        token = attach(main_context)  # Attach context to this thread
        try:
            return func()
        finally:
            detach(token)              # Detach after finishing
    return wrapper

# Example main execution logic:
# def main_concurrent_execution():
#     with tracer.start_as_current_span("main_operation") as parent_span:
#         parent_span.set_attribute("orchestrator", "ThreadPoolExecutor")
#         # Capture the context from the current thread (main_operation's context)
#         main_context_to_propagate = get_current()

#         # Create a list of functions to be executed in parallel
#         funcs_to_run = [func1, func2, func1, func2]
#         results = []

#         with concurrent.futures.ThreadPoolExecutor() as executor:
#             # Map each function to its wrapped version, passing the captured context
#             futures = [executor.submit(wrapped_func(f, main_context_to_propagate)) for f in funcs_to_run]
#             for future in concurrent.futures.as_completed(futures):
#                 results.append(future.result())
#         parent_span.set_attribute("results.count", len(results))
#     return results

# if __name__ == "__main__":
#     # Minimal OTel SDK setup for console output
#     from opentelemetry.sdk.trace import TracerProvider
#     from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
#     trace.set_tracer_provider(TracerProvider())
#     trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
#     final_results = main_concurrent_execution()
#     print(f"Concurrent execution results: {final_results}")

# The original return results was outside a function, wrapped it in main_concurrent_execution for clarity

import { trace, context, Context } from "@opentelemetry/api";
import { promisify } from "util";

const sleep = promisify(setTimeout);
const tracer = trace.getTracer("my-app-tracer-concurrent");

async function processItem(itemNumber: number, parentCtx: Context): Promise<string> {
    // Use context.with to ensure operations run within the parentCtx
    return await context.with(parentCtx, async () => {
        // This new span will be a child of the span in parentCtx (e.g., "main_async_operation")
        return await tracer.startActiveSpan(`process_item_${itemNumber}`, async (span) => {
            span.setAttribute("item.number", itemNumber);
            await sleep(Math.random() * 100); // Simulate async work
            const result = `Item ${itemNumber} processed`;
            span.setAttribute("output.value", result);
            span.end();
            return result;
        });
    });
}

async function mainAsyncOrchestration() {
    // Start a main parent span
    return await tracer.startActiveSpan("main_async_operation", async (parentSpan) => {
        parentSpan.setAttribute("orchestrator", "Promise.all");

        // Capture the context of the main_async_operation span
        const contextToPropagate = context.active();

        const itemsToProcess = [1, 2, 3, 4];
        const processingPromises = itemsToProcess.map(item =>
            processItem(item, contextToPropagate) // Pass the captured context to each task
        );

        const results = await Promise.all(processingPromises);
        parentSpan.setAttribute("results.count", results.length);
        parentSpan.end();
        return results;
    });
}

// Example usage:
// async function runExample() {
//     // Minimal OTel SDK setup for console output
//     const { NodeTracerProvider } = await import('@opentelemetry/sdk-trace-node');
//     const { ConsoleSpanExporter, SimpleSpanProcessor } = await import('@opentelemetry/sdk-trace-base');
//     const provider = new NodeTracerProvider();
//     provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
//     provider.register();

//     const finalResults = await mainAsyncOrchestration();
//     console.log("Async orchestration results:", finalResults);
// }
// runExample();