Skip to main content

​
Module

Galileo Decorator Module. This module provides decorators for logging and tracing function calls in your application. Decorators allow you to add logging functionality to your existing code with minimal changes. How to use decorators:
  1. Basic usage - decorate any function to log its execution: 
    from galileo import log

@log
def my_function(arg1, arg2):
    return arg1 + arg2
  2. You can annotate your logs to help categorize and search logs later on: 
    @log(span_type="llm", name="GPT-4 Call")
def call_llm(prompt, temperature=0.7):
    # LLM call implementation
    return response
    In this case, we are using:
    1. span_type - This groups the logs here into the “llm” category.
    2. name - This assigns a searchable name to all logs within this function.
  3. Using context manager for grouping related operations: 
    from galileo import galileo_context

with galileo_context(project="my-project", log_stream="production"):
    result1 = my_function()
    result2 = another_function()
Setup requirements:
  • Galileo API key must be set (via environment variable GALILEO_API_KEY or programmatically)
  • Project and Log Stream names should be defined if using the log decorator (either via environment variables GALILEO_PROJECT and GALILEO_LOG_STREAM, or via galileo_context.init())
For more examples and detailed usage, see the Galileo SDK documentation.

​
GalileoDecorator

Main decorator class that provides both decorator and context manager functionality for logging and tracing in Galileo. This class can be used as:
  1. A function decorator via the log method
  2. A context manager via the __call__ method

​
clear_session

def clear_session(self) -> None
Clear the session in the active context logger instance.

​
flush

def flush(self,
          project: Optional[str]=None,
          log_stream: Optional[str]=None,
          experiment_id: Optional[str]=None) -> None
Upload all captured traces under a project and log stream context to Galileo. If no project or log stream is provided, then the currently initialized context is used. Arguments
  • project: The project name. Defaults to None.
  • log_stream: The log stream name. Defaults to None.

​
flush_all

def flush_all(self) -> None
Upload all captured traces under all contexts to Galileo. This method flushes all traces regardless of project or log stream.

​
get_current_log_stream

def get_current_log_stream(self) -> Optional[str]
Retrieve the current log stream name from context. Returns
  • str | None: The current log stream context

​
get_current_mode

def get_current_mode(self) -> Optional[str]
Retrieve the current mode from context. Returns
  • str:

​
get_current_project

def get_current_project(self) -> Optional[str]
Retrieve the current project name from context. Returns
  • str | None: The current project context

​
get_current_span_stack

def get_current_span_stack(self) -> list[WorkflowSpan]
Retrieve the current span stack from context. Returns
  • List[WorkflowSpan]: The current span stack

​
get_current_trace

def get_current_trace(self) -> Optional[Trace]
Retrieve the current trace from context. Returns
  • Trace | None: The current trace

​
get_logger_instance

def get_logger_instance(self,
                        project: Optional[str]=None,
                        log_stream: Optional[str]=None,
                        experiment_id: Optional[str]=None) -> GalileoLogger
Get the Galileo Logger instance for the current decorator context. Arguments
  • project: Optional project name to use
  • log_stream: Optional log stream name to use
Returns
  • GalileoLogger instance configured with the specified project and log stream:

​
init

def init(self,
         project: Optional[str]=None,
         log_stream: Optional[str]=None,
         experiment_id: Optional[str]=None,
         local_metrics: Optional[list[LocalMetricConfig]]=None) -> None
Initialize the context with a project and log stream. Optionally, it can also be used to start a trace. This method resets the existing active context with a new context with the specified project and log stream. Arguments
  • project: The project name. Defaults to None.
  • log_stream: The log stream name. Defaults to None.
  • experiment_id: The experiment id. Defaults to None.
  • local_metrics: Local metrics configs to run on the traces/spans before submitting them for ingestion. Defaults to None.

​
log

def log(self,
        func: Optional[Callable[P, R]]=None,
        *,
        name: Optional[str]=None,
        span_type: Optional[SPAN_TYPE]=None,
        params: Optional[dict[str, Union[str, Callable]]]=None,
        dataset_record: Optional[DatasetRecord]=None) -> Callable[[Callable[P, R]], Callable[P, R]]
Main decorator function for logging function calls. This decorator can be used with or without arguments:
  • @log
  • @log(name=“my_function”, span_type=“llm”)
Arguments
  • func: The function to decorate (when used without parentheses)
  • name: Optional custom name for the span (defaults to function name)
  • span_type: Optional span type (“llm”, “retriever”, “tool”, “workflow”, “agent”)
  • params: Optional parameter mapping for extracting specific values
  • dataset_record: Optional parameter for dataset values. This is used by the local experiment module to set the dataset fields on the trace/spans and not generally provided for logging to log streams.
Returns
  • A decorated function that logs its execution:

​
reset

def reset(self) -> None
Reset the entire context, which also deletes all traces that haven’t been flushed. This method clears all context variables and resets the logger singleton.

​
reset_trace_context

def reset_trace_context(self) -> None
Reset the trace context inside the decorator.

​
set_session

def set_session(self, session_id: str) -> None
Set the session in the active context logger instance. This is useful when you want to continue logging to an existing session. Arguments
  • session_id: The id of the session to set.

​
start_session

def start_session(self,
                  name: Optional[str]=None,
                  previous_session_id: Optional[str]=None,
                  external_id: Optional[str]=None) -> str
Start a session in the active context logger instance. Arguments
  • name: The name of the session. If not provided, a session name will be generated automatically.
  • previous_session_id: The id of the previous session. Defaults to None.
  • external_id: The external id of the session. Defaults to None.
Returns
  • str: The id of the newly created session.
⌘I