Implementing Tracing

pip install fi-instrumentation-otel
pip install traceAI-openai

npm install @traceai/openai

import os
os.environ["FI_API_KEY"] = "your-futureagi-api-key"
os.environ["FI_SECRET_KEY"] = "your-futureagi-secret-key"

process.env.FI_API_KEY = FI_API_KEY;
process.env.FI_SECRET_KEY = FI_SECRET_KEY;

from traceai_openai import OpenAIInstrumentor
from fi_instrumentation import register

# Initialize OTel using our register function
trace_provider = register(
    project_type=ProjectType.EXPERIMENT,
    project_name="FUTURE_AGI",
    project_version_name="openai-exp",
)

const { register, ProjectType } = require("@traceai/fi-core");

const traceProvider = register({
    project_type: ProjectType.OBSERVE,
    project_name: "FUTURE_AGI"
});

OpenAIInstrumentor().instrument(tracer_provider=trace_provider)

const { OpenAIInstrumentation } = require("@traceai/openai");

const openaiInstrumentation = new OpenAIInstrumentation({});

registerInstrumentations({
    instrumentations: [openaiInstrumentation],
    tracerProvider: tracerProvider,
});

from opentelemetry import trace

trace.set_tracer_provider(trace_provider)
tracer = trace.get_tracer(__name__)

const { trace, context } = require("@opentelemetry/api");
const { AsyncLocalStorageContextManager } = require("@opentelemetry/context-async-hooks");
const { register } = require("@traceai/fi-core");
const { ProjectType } = require("@traceai/fi-core");
const { registerInstrumentations } = require("@opentelemetry/instrumentation");

// Activate a context manager for consistent context propagation
context.setGlobalContextManager(new AsyncLocalStorageContextManager());

// Initialize and get a tracer using our register function
const traceProvider = register({
    project_type: ProjectType.OBSERVE,
    project_name: "FUTURE_AGI"
});

const tracer = traceProvider.getTracer("manual-instrumentation-example");

def process_operation():
    with tracer.start_as_current_span("span-name") as span:
        # Execute operations tracked by 'span'
        print("doing some work...")
        # When the 'with' block goes out of scope, 'span' is automatically closed

function processOperation() {
    const q1 = () => tracer.startActiveSpan('processOperation', (span) => {
        span.setAttribute('operation', 'processOperation');
        span.end();
    });

    const q2 = () => tracer.startActiveSpan('processChildOperation', (span) => {
        span.setAttribute('operation', 'processChildOperation');
        span.end();
    });

    q1();
    q2();
}

def process_operation():
    with tracer.start_as_current_span("parent") as parent:
        # Execute parent-level operations
        print("doing some work...")
        # Create nested span for sub-operations
        with tracer.start_as_current_span("child") as child:
            # Execute child-level operations
            print("doing some nested work...")
            # Child span closes automatically when it's out of scope

// Implementation would be similar with nested startActiveSpan calls
function processOperation() {
    tracer.startActiveSpan("parent", (parentSpan) => {
        // Execute parent-level operations
        console.log("doing some work...");
        
        tracer.startActiveSpan("child", (childSpan) => {
            // Execute child-level operations
            console.log("doing some nested work...");
            childSpan.end();
        });
        
        parentSpan.end();
    });
}

@tracer.start_as_current_span("process_operation")
def process_operation():
    print("doing some work...")

// JavaScript doesn't have decorators in the same way, but you can achieve similar functionality
const decoratedFunction = (fn) => {
    return (...args) => {
        return tracer.startActiveSpan("process_operation", (span) => {
            try {
                const result = fn(...args);
                span.end();
                return result;
            } catch (error) {
                span.recordException(error);
                span.end();
                throw error;
            }
        });
    };
};

const processOperation = decoratedFunction(() => {
    console.log("doing some work...");
});