Tracer

from judgeval.tracer import Tracer

judgment = Tracer(
    project_name="default_project"
)

@judgment.observe(span_type="function")
def answer_question(question: str) -> str:
    answer = "The capital of the United States is Washington, D.C."
    return answer

@judgment.observe(span_type="tool")
def process_request(question: str) -> str:
    answer = answer_question(question)
    return answer

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

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?"))

from openai import OpenAI
from judgeval.tracer import Tracer

client = OpenAI()
tracer = Tracer(project_name='default_project', deep_tracing=False)
    
@tracer.observe(span_type="tool")
def search_web(query):
  return f"Results for: {query}"

@tracer.observe(span_type="retriever")
def get_database(query):
  return f"Database results for: {query}"

@tracer.observe(span_type="function")
def run_agent(user_query):
  # Use tools based on query
  if "database" in user_query:
      info = get_database(user_query)
  else:
      info = search_web(user_query)
  
  prompt = f"Context: {info}, Question: {user_query}"
  
  # Generate response
  response = client.chat.completions.create(
      model="gpt-5",
      messages=[{"role": "user", "content": prompt}]
  )
  return response.choices[0].message.content

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