traced()

import { init, traced } from 'gentrace';
import OpenAI from 'openai';

init({
  apiKey: process.env.GENTRACE_API_KEY,
});

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function generateResponse(prompt: string): Promise<string> {
  const response = await openai.chat.completions.create({
    model: 'o3',
    messages: [{ role: 'user', content: prompt }],
  });
  return response.choices[0].message.content || '';
}

const tracedGenerateResponse = traced(
  'generateResponse',
  generateResponse,
);
const aiResponse = await tracedGenerateResponse(
  'What is the capital of France?',
);

import asyncio
import os
from gentrace import init, traced
from openai import OpenAI

init(api_key=os.environ["GENTRACE_API_KEY"])

openai = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

@traced(name="generate_response")
async def generate_response(prompt: str) -> str:
    response = await openai.chat.completions.create(
        model="o3",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content or ""

# Run the async function
async def main():
    ai_response = await generate_response("What is the capital of France?")
    print(ai_response)

asyncio.run(main())

/**
 * Wrap a function with OpenTelemetry tracing
 *
 * @param name - The name for the OpenTelemetry span.
 *               This will appear in your tracing dashboard
 * @param fn - The function to wrap with tracing.
 *             Can be synchronous or asynchronous
 * @param config - Additional configuration options
 * @param config.attributes - Custom attributes to attach
 *                            to the span for additional context
 *
 * @returns The wrapped function with the same signature
 *          but enhanced with tracing capabilities
 */
function traced<F extends (...args: any[]) => any>(
  name: string,
  fn: F,
  config?: {
    attributes?: Record<string, any>;
  },
): F;

def traced(
    *,
    name: Optional[str] = None,
    attributes: Optional[Dict[str, Any]] = None,
) -> Callable[[F], F]:
    """
    Decorator to wrap a function with OpenTelemetry tracing

    Args:
        name: Custom name for the OpenTelemetry span.
              If not provided, uses the function's __name__
              or "anonymous_function" as fallback
        attributes: Custom attributes to attach to the span.
                    These will be formatted for OTLP compatibility

    Returns:
        A decorator that, when applied to a function,
        returns a new function with the same signature
        but enhanced with tracing capabilities
    """