Tracer

from judgeval.tracer import Tracer, wrap
from openai import OpenAI

judgment = Tracer(
    project_name="default_project"
)
client = wrap(OpenAI())

class QAAgent:
    def __init__(self, client):
        self.client = client

    @judgment.observe(span_type="tool")
    def process_query(self, query):
        response = self.client.chat.completions.create(
            model="gpt-5",
            messages=[
                {"role": "system", "content": "You are a helpful assitant"},
                {"role": "user", "content": f"I have a query: {query}"}]
        )
        return f"Response: {response.choices[0].message.content}"

    @judgment.agent()
    @judgment.observe(span_type="agent")
    def invoke_agent(self, query):
        result = self.process_query(query)
        return result


if __name__ == "__main__":
    agent = QAAgent(client)
    print(agent.invoke_agent("What is the capital of the United States?"))

Tracer(
    api_key: str,
    organization_id: str,
    project_name: str,
    enable_monitoring: bool = True,
    enable_evaluations: bool = True,
    resource_attributes: Optional[Dict[str, Any]] = None
)

from judgeval.tracer import Tracer

judgment = Tracer(
    project_name="default_project"
)

from openai import OpenAI
from judgeval.tracer import wrap

client = OpenAI()
wrapped_client = wrap(client)

# All API calls are now automatically traced
response = wrapped_client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Hello"}]
)

# Streaming calls are also traced
stream = wrapped_client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Hello"}],
    stream=True
)

from judgeval.scorers import AnswerRelevancyScorer
from judgeval.data import Example
from judgeval.tracer import Tracer

judgment = Tracer(project_name="default_project")

@judgment.observe(span_type="function")
def agent(question: str) -> str:
    answer = "Paris is the capital of France"

    # Create example object
    example = Example(
        input=question,
        actual_output=answer,
    )

    # Evaluate using Example
    judgment.async_evaluate(
        scorer=AnswerRelevancyScorer(threshold=0.5),
        example=example,
        model="gpt-5",
        sampling_rate=0.9
    )

    return answer

if __name__ == "__main__":
    print(agent("What is the capital of France?"))

from judgeval.tracer import Tracer

judgment = Tracer(project_name="default_project")

class TravelAgent:
    def __init__(self, id):
        self.id = id

    @judgment.observe(span_type="tool")
    def book_flight(self, destination):
        return f"Flight booked to {destination}!"

    @judgment.agent(identifier="id")
    @judgment.observe(span_type="function")
    def invoke_agent(self, destination):
        flight_info = self.book_flight(destination)
        return f"Here is your requested flight info: {flight_info}"

if __name__ == "__main__":
    agent = TravelAgent("travel_agent_1")
    print(agent.invoke_agent("Paris"))

    agent2 = TravelAgent("travel_agent_2")
    print(agent2.invoke_agent("New York"))

judgment = Tracer(project_name="default_project")

# Retrieve a trace scorer to be used with the TraceScorerConfig
trace_scorer = TracePromptScorer.get(name="sample_trace_scorer")

# A trace eval is only triggered if process_request() is called with x > 10
@judgment.observe(
  span_type="function",
  scorer_config=TraceScorerConfig(
    scorer=trace_scorer,
    sampling_rate=1.0,
    run_condition=lambda x: x > 10
  )
)
def process_request(x):
  return x + 1

@tracer.observe(span_type="tool")
def debug_tool(query):
    span = tracer.get_current_span()
    if span:
        # Access span properties for debugging
        print(f"Executing {span.function} (ID: {span.span_id})")
        print(f"Depth: {span.depth}, Type: {span.span_type}")
        print(f"Inputs: {span.inputs}")

        # Check parent relationship
        if span.parent_span_id:
            print(f"Parent span: {span.parent_span_id}")

        # Monitor execution state
        if span.agent_name:
            print(f"Agent: {span.agent_name}")

    result = perform_search(query)

    # Check span after execution
    if span:
        print(f"Output: {span.output}")
        print(f"Duration: {span.duration}s")
        if span.has_evaluation:
            print(f"Has {len(span.evaluation_runs)} evaluations")
        if span.error:
            print(f"Error: {span.error}")

    return result

from judgeval.tracer import Tracer
from opentelemetry.sdk.trace import TracerProvider

tracer_provider = TracerProvider()

# Initialize tracer with OpenTelemetry configuration
judgment = Tracer(
    project_name="default_project",
    resource_attributes={
        "service.name": "my-ai-agent",
        "service.version": "1.2.0",
        "deployment.environment": "production"
    }
)

tracer_provider.add_span_processor(judgment.get_processor())
tracer = tracer_provider.get_tracer(__name__)

def answer_question(question: str) -> str:
    with tracer.start_as_current_span("answer_question_span") as span:
        span.set_attribute("question", question)
        answer = "The capital of the United States is Washington, D.C."
        span.set_attribute("answer", answer)
    return answer

def process_request(question: str) -> str:
    with tracer.start_as_current_span("process_request_span") as span:
        span.set_attribute("input", question)
        answer = answer_question(question)
        span.set_attribute("output", answer)
    return answer

if __name__ == "__main__":
    print(process_request("What is the capital of the United States?"))