diff --git a/src/splunk_ao/configuration.py b/src/splunk_ao/configuration.py index 38b220d1..d4744969 100644 --- a/src/splunk_ao/configuration.py +++ b/src/splunk_ao/configuration.py @@ -502,16 +502,16 @@ def disable_console_logging(cls) -> None: Configuration.disable_console_logging() ``` """ - galileo_logger = logging.getLogger(SDK_LOGGER_NAME) + splunk_ao_logger = logging.getLogger(SDK_LOGGER_NAME) # Remove all stream handlers - for handler in galileo_logger.handlers[:]: + for handler in splunk_ao_logger.handlers[:]: if isinstance(handler, logging.StreamHandler): - galileo_logger.removeHandler(handler) + splunk_ao_logger.removeHandler(handler) # Set level to suppress all output - galileo_logger.setLevel(logging.CRITICAL + 1) - galileo_logger.propagate = False + splunk_ao_logger.setLevel(logging.CRITICAL + 1) + splunk_ao_logger.propagate = False # Clear the stored log level cls.log_level = None diff --git a/src/splunk_ao/handlers/agent_control/bridge.py b/src/splunk_ao/handlers/agent_control/bridge.py index fe720eb5..1da1190b 100644 --- a/src/splunk_ao/handlers/agent_control/bridge.py +++ b/src/splunk_ao/handlers/agent_control/bridge.py @@ -161,8 +161,8 @@ class SplunkAOAgentControlBridge: safely rather than attached to the wrong logger hierarchy. """ - def __init__(self, galileo_logger: SplunkAOLogger) -> None: - self._galileo_logger = galileo_logger + def __init__(self, splunk_ao_logger: SplunkAOLogger) -> None: + self._splunk_ao_logger = splunk_ao_logger self._modules = _load_agent_control_modules() self._sink = _SplunkAOControlEventSink(self) self._registered = False @@ -225,7 +225,7 @@ def write_events(self, events: Any) -> Any: continue try: - result = self._galileo_logger.add_control_span(**self._control_span_kwargs(event)) + result = self._splunk_ao_logger.add_control_span(**self._control_span_kwargs(event)) except Exception: logger.warning("Agent Control event conversion failed", exc_info=True) dropped += 1 @@ -241,7 +241,7 @@ def _sink_result(self, *, accepted: int, dropped: int) -> Any: return self._modules.sinks.SinkResult(accepted=accepted, dropped=dropped) def _active_context(self) -> _ActiveContext | None: - current_parent = self._galileo_logger.current_parent() + current_parent = self._splunk_ao_logger.current_parent() if current_parent is None or current_parent.id is None: return None @@ -300,6 +300,6 @@ def _control_span_kwargs(event: Any) -> dict[str, Any]: } -def setup_agent_control_bridge(galileo_logger: SplunkAOLogger) -> SplunkAOAgentControlBridge: +def setup_agent_control_bridge(splunk_ao_logger: SplunkAOLogger) -> SplunkAOAgentControlBridge: """Create and register an Agent Control bridge for a Galileo logger.""" - return galileo_logger.enable_agent_control() + return splunk_ao_logger.enable_agent_control() diff --git a/src/splunk_ao/handlers/base_async_handler.py b/src/splunk_ao/handlers/base_async_handler.py index ea55e89d..29a72cd9 100644 --- a/src/splunk_ao/handlers/base_async_handler.py +++ b/src/splunk_ao/handlers/base_async_handler.py @@ -16,7 +16,7 @@ class SplunkAOAsyncBaseHandler(SplunkAOBaseHandler): Attributes ---------- - _galileo_logger : SplunkAOLogger + _splunk_ao_logger : SplunkAOLogger The Galileo logger instance. _nodes : dict[UUID, Node] A dictionary of nodes, where the key is the run_id and the value is the node. @@ -43,7 +43,7 @@ async def async_commit(self) -> None: return if self._start_new_trace: - self._galileo_logger.start_trace( + self._splunk_ao_logger.start_trace( input=serialize_to_str(root_node.span_params.get("input", "")), name=root_node.span_params.get("name"), metadata=root_node.span_params.get("metadata"), @@ -56,13 +56,13 @@ async def async_commit(self) -> None: if self._start_new_trace: # If we started a new trace, we need to conclude it - self._galileo_logger.conclude( + self._splunk_ao_logger.conclude( output=serialize_to_str(root_output), status_code=root_node.span_params.get("status_code") ) if self._flush_on_chain_end: # Upload the trace to Galileo - await self._galileo_logger.async_flush() + await self._splunk_ao_logger.async_flush() # Clear nodes after successful commit self._nodes.clear() diff --git a/src/splunk_ao/handlers/base_handler.py b/src/splunk_ao/handlers/base_handler.py index eec04caa..65a22f91 100644 --- a/src/splunk_ao/handlers/base_handler.py +++ b/src/splunk_ao/handlers/base_handler.py @@ -20,7 +20,7 @@ class SplunkAOBaseHandler: Attributes ---------- - _galileo_logger : SplunkAOLogger + _splunk_ao_logger : SplunkAOLogger The Galileo logger instance. _nodes : dict[UUID, Node] A dictionary of nodes, where the key is the run_id and the value is the node. @@ -39,18 +39,18 @@ class SplunkAOBaseHandler: def __init__( self, integration: INTEGRATION = "langchain", - galileo_logger: SplunkAOLogger | None = None, + splunk_ao_logger: SplunkAOLogger | None = None, start_new_trace: bool = True, flush_on_chain_end: bool = True, ingestion_hook: Callable[[TracesIngestRequest], None] | None = None, ): - self._galileo_logger: SplunkAOLogger = galileo_logger or splunk_ao_context.get_logger_instance( + self._splunk_ao_logger: SplunkAOLogger = splunk_ao_logger or splunk_ao_context.get_logger_instance( ingestion_hook=ingestion_hook ) - if galileo_logger and ingestion_hook: - if self._galileo_logger.mode == "distributed": + if splunk_ao_logger and ingestion_hook: + if self._splunk_ao_logger.mode == "distributed": raise ValueError("ingestion_hook can only be used in batch mode") - self._galileo_logger._ingestion_hook = ingestion_hook + self._splunk_ao_logger._ingestion_hook = ingestion_hook self._start_new_trace: bool = start_new_trace self._flush_on_chain_end: bool = flush_on_chain_end self._nodes: dict[str, Node] = {} @@ -75,7 +75,7 @@ def commit(self) -> None: try: if self._start_new_trace: - self._galileo_logger.start_trace( + self._splunk_ao_logger.start_trace( input=SplunkAOLogger._coerce_output(root_node.span_params.get("input", "")), name=root_node.span_params.get("name"), metadata=root_node.span_params.get("metadata"), @@ -87,13 +87,13 @@ def commit(self) -> None: root_output = root_node.span_params.get("output", "") if self._start_new_trace: - self._galileo_logger.conclude( + self._splunk_ao_logger.conclude( output=SplunkAOLogger._coerce_output(root_output), status_code=root_node.span_params.get("status_code"), ) if self._flush_on_chain_end: - self._galileo_logger.flush() + self._splunk_ao_logger.flush() finally: # Always clean up, even if trace building or flush fails self._nodes.clear() @@ -129,7 +129,7 @@ def log_node_tree(self, node: Node) -> None: # Log the current node based on its type if node.node_type == "chain": - self._galileo_logger.add_workflow_span( + self._splunk_ao_logger.add_workflow_span( input=input_, output=output, name=name, @@ -142,7 +142,7 @@ def log_node_tree(self, node: Node) -> None: ) is_span_with_children = True elif node.node_type == "agent": - self._galileo_logger.add_agent_span( + self._splunk_ao_logger.add_agent_span( input=input_, output=output, name=name, @@ -155,7 +155,7 @@ def log_node_tree(self, node: Node) -> None: ) is_span_with_children = True elif node.node_type in ("llm", "chat"): - self._galileo_logger.add_llm_span( + self._splunk_ao_logger.add_llm_span( input=input_, output=output, model=node.span_params.get("model"), @@ -174,7 +174,7 @@ def log_node_tree(self, node: Node) -> None: status_code=node.span_params.get("status_code"), ) elif node.node_type == "retriever": - self._galileo_logger.add_retriever_span( + self._splunk_ao_logger.add_retriever_span( input=input_, output=output, name=name, @@ -185,7 +185,7 @@ def log_node_tree(self, node: Node) -> None: step_number=step_number, ) elif node.node_type == "tool": - tool_span = self._galileo_logger.add_tool_span( + tool_span = self._splunk_ao_logger.add_tool_span( input=input_, output=output, name=name, @@ -199,9 +199,9 @@ def log_node_tree(self, node: Node) -> None: ) # If tool has children (e.g., agent-as-tool invocations), push it to parent stack if node.children and tool_span is not None: - parent_before_tool = self._galileo_logger.current_parent() + parent_before_tool = self._splunk_ao_logger.current_parent() tool_span._parent = parent_before_tool - self._galileo_logger._set_current_parent(tool_span) + self._splunk_ao_logger._set_current_parent(tool_span) is_span_with_children = True else: _logger.warning(f"Unknown node type: {node.node_type}") @@ -219,7 +219,7 @@ def log_node_tree(self, node: Node) -> None: # Conclude parent span. Use the last child's output if necessary if is_span_with_children: output = output or (last_child.span_params.get("output", "") if last_child else "") - self._galileo_logger.conclude( + self._splunk_ao_logger.conclude( output=serialize_to_str(output), status_code=node.span_params.get("status_code") ) diff --git a/src/splunk_ao/handlers/crewai/handler.py b/src/splunk_ao/handlers/crewai/handler.py index 11ae609b..b057bbfa 100644 --- a/src/splunk_ao/handlers/crewai/handler.py +++ b/src/splunk_ao/handlers/crewai/handler.py @@ -65,7 +65,7 @@ class CrewAIEventListener: def __init__( self, - galileo_logger: SplunkAOLogger | None = None, + splunk_ao_logger: SplunkAOLogger | None = None, start_new_trace: bool = True, flush_on_crew_completed: bool = True, ): @@ -74,7 +74,7 @@ def __init__( self._handler = SplunkAOBaseHandler( flush_on_chain_end=flush_on_crew_completed, start_new_trace=start_new_trace, - galileo_logger=galileo_logger, + splunk_ao_logger=splunk_ao_logger, integration="crewai", ) self._active_tool_run_id: UUID | None = None diff --git a/src/splunk_ao/handlers/langchain/async_handler.py b/src/splunk_ao/handlers/langchain/async_handler.py index 78706f09..d4548e7b 100644 --- a/src/splunk_ao/handlers/langchain/async_handler.py +++ b/src/splunk_ao/handlers/langchain/async_handler.py @@ -44,7 +44,7 @@ class SplunkAOAsyncCallback(AsyncCallbackHandler): def __init__( self, - galileo_logger: SplunkAOLogger | None = None, + splunk_ao_logger: SplunkAOLogger | None = None, start_new_trace: bool = True, flush_on_chain_end: bool = True, ingestion_hook: Callable[[TracesIngestRequest], None] | None = None, @@ -52,7 +52,7 @@ def __init__( self._handler = SplunkAOAsyncBaseHandler( flush_on_chain_end=flush_on_chain_end, start_new_trace=start_new_trace, - galileo_logger=galileo_logger, + splunk_ao_logger=splunk_ao_logger, integration="langchain", ingestion_hook=ingestion_hook, ) diff --git a/src/splunk_ao/handlers/langchain/handler.py b/src/splunk_ao/handlers/langchain/handler.py index 2477c56d..f1fd2bd8 100644 --- a/src/splunk_ao/handlers/langchain/handler.py +++ b/src/splunk_ao/handlers/langchain/handler.py @@ -43,7 +43,7 @@ class SplunkAOCallback(BaseCallbackHandler): def __init__( self, - galileo_logger: SplunkAOLogger | None = None, + splunk_ao_logger: SplunkAOLogger | None = None, start_new_trace: bool = True, flush_on_chain_end: bool = True, ingestion_hook: Callable[[TracesIngestRequest], None] | None = None, @@ -51,7 +51,7 @@ def __init__( self._handler = SplunkAOBaseHandler( flush_on_chain_end=flush_on_chain_end, start_new_trace=start_new_trace, - galileo_logger=galileo_logger, + splunk_ao_logger=splunk_ao_logger, integration="langchain", ingestion_hook=ingestion_hook, ) diff --git a/src/splunk_ao/handlers/langchain/middleware.py b/src/splunk_ao/handlers/langchain/middleware.py index 7ba23a2d..df0fb382 100644 --- a/src/splunk_ao/handlers/langchain/middleware.py +++ b/src/splunk_ao/handlers/langchain/middleware.py @@ -39,7 +39,7 @@ def __init__(self, *args, **kwargs): class SplunkAOMiddleware(AgentMiddleware): def __init__( self, - galileo_logger: SplunkAOLogger | None = None, + splunk_ao_logger: SplunkAOLogger | None = None, start_new_trace: bool = True, flush_on_chain_end: bool = True, ingestion_hook: Callable[[TracesIngestRequest], None] | None = None, @@ -50,14 +50,14 @@ def __init__( self._handler = SplunkAOBaseHandler( flush_on_chain_end=flush_on_chain_end, start_new_trace=start_new_trace, - galileo_logger=galileo_logger, + splunk_ao_logger=splunk_ao_logger, integration="langchain", ingestion_hook=ingestion_hook, ) self._async_handler = SplunkAOAsyncBaseHandler( flush_on_chain_end=flush_on_chain_end, start_new_trace=start_new_trace, - galileo_logger=galileo_logger, + splunk_ao_logger=splunk_ao_logger, integration="langchain", ingestion_hook=ingestion_hook, ) diff --git a/src/splunk_ao/handlers/openai_agents/handler.py b/src/splunk_ao/handlers/openai_agents/handler.py index 77666a55..e34a8032 100644 --- a/src/splunk_ao/handlers/openai_agents/handler.py +++ b/src/splunk_ao/handlers/openai_agents/handler.py @@ -33,7 +33,7 @@ class SplunkAOTracingProcessor(TracingProcessor): Attributes ---------- - _galileo_logger : SplunkAOLogger + _splunk_ao_logger : SplunkAOLogger The Galileo logger instance. _flush_on_trace_end : bool Whether to automatically flush the log batch to Galileo when a trace ends. @@ -41,18 +41,18 @@ class SplunkAOTracingProcessor(TracingProcessor): Stores Node objects keyed by their OpenAI span_id or trace_id (for root). """ - def __init__(self, galileo_logger: SplunkAOLogger | None = None, flush_on_trace_end: bool = True): + def __init__(self, splunk_ao_logger: SplunkAOLogger | None = None, flush_on_trace_end: bool = True): """ OpenAI Agents TracingProcessor for logging traces to Galileo. Parameters ---------- - galileo_logger : Optional[SplunkAOLogger] + splunk_ao_logger : Optional[SplunkAOLogger] The Galileo logger instance. If None, a default instance is created. flush_on_trace_end : bool Whether to automatically flush the log batch to Galileo when a trace ends. """ - self._galileo_logger: SplunkAOLogger = galileo_logger or splunk_ao_context.get_logger_instance() + self._splunk_ao_logger: SplunkAOLogger = splunk_ao_logger or splunk_ao_context.get_logger_instance() self._flush_on_trace_end: bool = flush_on_trace_end self._nodes: dict[str, Node] = {} self._last_output: Any = None @@ -92,7 +92,7 @@ def on_trace_end(self, trace: Trace) -> None: # Optionally flush the log batch if self._flush_on_trace_end: - self._galileo_logger.flush() + self._splunk_ao_logger.flush() def _commit_trace(self, trace: Trace) -> None: if not self._nodes: @@ -104,7 +104,7 @@ def _commit_trace(self, trace: Trace) -> None: self._log_node_tree(root_node, first_node=True) else: _logger.warning(f"Root node {trace.trace_id} not found") - self._galileo_logger.conclude(output=self._last_output, status_code=self._last_status_code) + self._splunk_ao_logger.conclude(output=self._last_output, status_code=self._last_status_code) def _log_node_tree(self, node: Node, first_node: bool = False) -> None: """ @@ -129,7 +129,7 @@ def _log_node_tree(self, node: Node, first_node: bool = False) -> None: if metadata is not None: metadata = convert_to_string_dict(metadata) if first_node: - self._galileo_logger.add_trace( + self._splunk_ao_logger.add_trace( input=self._first_input or "Agent Workflow", output=self._last_output, duration_ns=node.span_params.get("duration_ns"), @@ -139,7 +139,7 @@ def _log_node_tree(self, node: Node, first_node: bool = False) -> None: ) # Log the current node based on its type elif node.node_type in ("agent", "chain", "workflow"): - self._galileo_logger.add_workflow_span( + self._splunk_ao_logger.add_workflow_span( input=input or node.node_type.capitalize() + " Step", output=output, name=name, @@ -180,9 +180,9 @@ def _log_node_tree(self, node: Node, first_node: bool = False) -> None: status_code=node.span_params.get("status_code", 200), id=uuid.uuid4(), ) - self._galileo_logger.add_child_span_to_parent(span) + self._splunk_ao_logger.add_child_span_to_parent(span) elif node.node_type == "retriever": - self._galileo_logger.add_retriever_span( + self._splunk_ao_logger.add_retriever_span( input=input, output=output, name=name, @@ -192,7 +192,7 @@ def _log_node_tree(self, node: Node, first_node: bool = False) -> None: duration_ns=node.span_params.get("duration_ns"), ) elif node.node_type == "tool": - self._galileo_logger.add_tool_span( + self._splunk_ao_logger.add_tool_span( input=input or node.node_type, output=output, name=name, @@ -222,7 +222,7 @@ def _log_node_tree(self, node: Node, first_node: bool = False) -> None: if error: output = error status_code = 500 - self._galileo_logger.conclude(output=serialize_to_str(output), status_code=status_code) + self._splunk_ao_logger.conclude(output=serialize_to_str(output), status_code=status_code) self._last_status_code = status_code self._last_output = output @@ -236,7 +236,7 @@ def on_span_start(self, span: Span[Any]) -> None: _logger.warning(f"Span node already exists for span_id {span_id}, overwriting...") # Determine span type and name - galileo_type = _map_span_type(span.span_data) + splunk_ao_type = _map_span_type(span.span_data) span_name = _map_span_name(span) # Extract initial data based on type @@ -244,7 +244,7 @@ def on_span_start(self, span: Span[Any]) -> None: "name": span_name, "start_time_iso": span.started_at or datetime.now(timezone.utc).isoformat(), } - if galileo_type in ["llm", "chat"]: + if splunk_ao_type in ["llm", "chat"]: llm_data = _extract_llm_data(span.span_data) initial_params.update( { @@ -259,7 +259,7 @@ def on_span_start(self, span: Span[Any]) -> None: ) if not self._first_input and initial_params.get("input") != serialize_to_str(None): self._first_input = initial_params.get("input") - elif galileo_type == "tool": + elif splunk_ao_type == "tool": tool_data = _extract_tool_data(span.span_data) initial_params.update( { @@ -268,7 +268,7 @@ def on_span_start(self, span: Span[Any]) -> None: "status_code": tool_data.get("status_code", 200), } ) - elif galileo_type == "workflow": + elif splunk_ao_type == "workflow": wf_data = _extract_workflow_data(span.span_data) initial_params.update( { @@ -277,7 +277,7 @@ def on_span_start(self, span: Span[Any]) -> None: "status_code": wf_data.get("status_code", 200), } ) - elif galileo_type == "galileo_custom": + elif splunk_ao_type == "splunk_ao_custom": custom_span = cast(SplunkAOCustomSpan, span.span_data) initial_params.update( { @@ -288,13 +288,13 @@ def on_span_start(self, span: Span[Any]) -> None: "status_code": custom_span.span.status_code, } ) - galileo_type = custom_span.span.type.value + splunk_ao_type = custom_span.span.type.value - if galileo_type == "galileo_custom": - galileo_type = "workflow" + if splunk_ao_type == "splunk_ao_custom": + splunk_ao_type = "workflow" # Create the node - node = Node(node_type=galileo_type, span_params=initial_params, run_id=span_id, parent_run_id=parent_id) + node = Node(node_type=splunk_ao_type, span_params=initial_params, run_id=span_id, parent_run_id=parent_id) self._nodes[span_id] = node # Add to parent's children list @@ -315,13 +315,13 @@ def on_span_end(self, span: Span[Any]) -> None: node.span_params["name"] = _map_span_name(span) # Update node with final data - galileo_type = node.node_type + splunk_ao_type = node.node_type end_params: dict[str, Any] = {"end_time_iso": span.ended_at or datetime.now(timezone.utc).isoformat()} end_params["duration_ns"] = convert_time_delta_to_ns( datetime.fromisoformat(span.ended_at) - datetime.fromisoformat(node.span_params["start_time_iso"]) ) - if galileo_type == "llm": + if splunk_ao_type == "llm": llm_data = _extract_llm_data(span.span_data) end_params.update( { @@ -349,7 +349,7 @@ def on_span_end(self, span: Span[Any]) -> None: existing_tools = [] end_params["tools"] = existing_tools + embedded_tool_calls - elif galileo_type == "tool": + elif splunk_ao_type == "tool": tool_data = _extract_tool_data(span.span_data) end_params.update( { @@ -361,7 +361,7 @@ def on_span_end(self, span: Span[Any]) -> None: if node.span_params.get("input") is None: node.span_params["input"] = tool_data.get("input") - elif galileo_type == "workflow": + elif splunk_ao_type == "workflow": wf_data = _extract_workflow_data(span.span_data) end_params.update( { @@ -390,11 +390,11 @@ def on_span_end(self, span: Span[Any]) -> None: def shutdown(self) -> None: """Called when the application stops. Flushes any remaining logs.""" - self._galileo_logger.flush() + self._splunk_ao_logger.flush() def force_flush(self) -> None: """Forces an immediate flush of all queued traces/spans.""" - self._galileo_logger.flush() + self._splunk_ao_logger.flush() def _extract_embedded_tool_calls(self, response: Any) -> list[dict[str, Any]]: """Extract embedded tool calls from response.output.""" diff --git a/src/splunk_ao/logger/logger.py b/src/splunk_ao/logger/logger.py index 1d08fe13..83e713df 100644 --- a/src/splunk_ao/logger/logger.py +++ b/src/splunk_ao/logger/logger.py @@ -918,7 +918,7 @@ def enable_agent_control(self) -> "SplunkAOAgentControlBridge": bridge = getattr(self, "_agent_control_bridge", None) if bridge is None: - bridge = SplunkAOAgentControlBridge(galileo_logger=self) + bridge = SplunkAOAgentControlBridge(splunk_ao_logger=self) self._agent_control_bridge = bridge bridge.register() return bridge diff --git a/src/splunk_ao/openai/__init__.py b/src/splunk_ao/openai/__init__.py index 8c910c6f..9d5ca676 100644 --- a/src/splunk_ao/openai/__init__.py +++ b/src/splunk_ao/openai/__init__.py @@ -133,12 +133,12 @@ def _wrap( input_data = extract_input_data_from_kwargs(open_ai_resource, start_time, arg_extractor.get_splunk_ao_args()) - galileo_logger = _safe_initialize_logger(initialize) - if galileo_logger is None: + splunk_ao_logger = _safe_initialize_logger(initialize) + if splunk_ao_logger is None: return wrapped(**arg_extractor.get_openai_args()) should_complete_trace = False - if galileo_logger.current_parent(): + if splunk_ao_logger.current_parent(): pass else: # If we don't have an active trace, start a new trace @@ -151,7 +151,7 @@ def _wrap( # Serialize with "messages" wrapper for UI compatibility trace_input = {"messages": [msg.model_dump(exclude_none=True) for msg in trace_input_messages]} - galileo_logger.start_trace(input=serialize_to_str(trace_input), name=input_data.name) + splunk_ao_logger.start_trace(input=serialize_to_str(trace_input), name=input_data.name) should_complete_trace = True try: @@ -170,7 +170,7 @@ def _wrap( resource=open_ai_resource, response=openai_response, input_data=input_data, - logger=galileo_logger, + logger=splunk_ao_logger, should_complete_trace=should_complete_trace, status_code=status_code, ) @@ -198,7 +198,7 @@ def _wrap( # First, process any function_call_output items in the input to create tool spans # This represents tool executions that happened before this API call if isinstance(input_data.input, list): - process_function_call_outputs(input_data.input, galileo_logger) + process_function_call_outputs(input_data.input, splunk_ao_logger) # Get output_items safely for Responses API # First try direct attribute access (works for Pydantic models) @@ -216,7 +216,7 @@ def _wrap( # Process all output items sequentially and get the final context final_conversation_context = process_output_items( output_items, - galileo_logger, + splunk_ao_logger, model, span_input, input_data.model_parameters, @@ -229,7 +229,7 @@ def _wrap( span_output = convert_to_splunk_ao_message(completion, "assistant") # Add a span to the current trace or span (if this is a nested trace) - span = galileo_logger.add_llm_span( + span = splunk_ao_logger.add_llm_span( input=span_input, output=span_output, tools=input_data.tools, @@ -269,7 +269,7 @@ def _wrap( # Serialize with "messages" wrapper for UI compatibility trace_output = {"messages": [msg.model_dump(exclude_none=True) for msg in full_conversation]} - galileo_logger.conclude( + splunk_ao_logger.conclude( output=serialize_to_str(trace_output), duration_ns=duration_ns, status_code=status_code ) @@ -290,11 +290,11 @@ class OpenAIGalileo: Attributes ---------- - _galileo_logger : Optional[SplunkAOLogger] + _splunk_ao_logger : Optional[SplunkAOLogger] The Galileo logger instance used for logging OpenAI API calls. """ - _galileo_logger: SplunkAOLogger | None = None + _splunk_ao_logger: SplunkAOLogger | None = None def initialize(self) -> SplunkAOLogger | None: """ @@ -312,9 +312,9 @@ def initialize(self) -> SplunkAOLogger | None: Optional[SplunkAOLogger] The initialized Galileo logger instance. """ - self._galileo_logger = splunk_ao_context.get_logger_instance() + self._splunk_ao_logger = splunk_ao_context.get_logger_instance() - return self._galileo_logger + return self._splunk_ao_logger def register_tracing(self) -> None: """ diff --git a/src/splunk_ao/openai/extractors.py b/src/splunk_ao/openai/extractors.py index bf2ead0e..71e2ee5f 100644 --- a/src/splunk_ao/openai/extractors.py +++ b/src/splunk_ao/openai/extractors.py @@ -481,7 +481,7 @@ def _extract_message_content(item: ResponseOutputMessage) -> str: return str(content) if content else "" -def process_function_call_outputs(input_items: list, galileo_logger: SplunkAOLogger) -> None: +def process_function_call_outputs(input_items: list, splunk_ao_logger: SplunkAOLogger) -> None: """ Process function_call and function_call_output items from the input and create combined tool spans. This joins the function call (model's request to call a tool) with the function output (tool result) @@ -527,7 +527,7 @@ def process_function_call_outputs(input_items: list, galileo_logger: SplunkAOLog ) tool_output = json.dumps(output) if isinstance(output, dict) else str(output) - galileo_logger.add_tool_span( + splunk_ao_logger.add_tool_span( input=tool_input, output=tool_output, name=function_call.get("name") or "function_call", @@ -537,7 +537,7 @@ def process_function_call_outputs(input_items: list, galileo_logger: SplunkAOLog def process_output_items( output_items: list, - galileo_logger: SplunkAOLogger, + splunk_ao_logger: SplunkAOLogger, model: str | None = None, original_input: list | None = None, model_parameters: dict | None = None, @@ -626,7 +626,7 @@ def process_output_items( ] # Create single consolidated span with serialized messages - span = galileo_logger.add_llm_span( + span = splunk_ao_logger.add_llm_span( input=conversation_context, output=consolidated_output, model=model, @@ -663,7 +663,7 @@ def process_output_items( tool_input, tool_output = extractor(item) # Create tool span with the tool type as the name - galileo_logger.add_tool_span( + splunk_ao_logger.add_tool_span( input=tool_input, output=tool_output, name=item.type, diff --git a/src/splunk_ao/utils/openai_agents.py b/src/splunk_ao/utils/openai_agents.py index 1c7a24be..be6d4c8e 100644 --- a/src/splunk_ao/utils/openai_agents.py +++ b/src/splunk_ao/utils/openai_agents.py @@ -26,11 +26,11 @@ def __init__(self, span: GalileoSpan, data: dict[str, Any]): super().__init__(span.name, data) @property - def type(self) -> Literal["galileo_custom"]: - return "galileo_custom" + def type(self) -> Literal["splunk_ao_custom"]: + return "splunk_ao_custom" -def _map_span_type(span_data: SpanData, span: Span[Any] | None = None) -> SPAN_TYPE | Literal["galileo_custom"]: +def _map_span_type(span_data: SpanData, span: Span[Any] | None = None) -> SPAN_TYPE | Literal["splunk_ao_custom"]: """Determine the Galileo span type based on the OpenAI Agent span data.""" if isinstance(span_data, GenerationSpanData | ResponseSpanData): return "llm" diff --git a/src/splunk_ao/utils/singleton.py b/src/splunk_ao/utils/singleton.py index ef692eb7..3f5a3910 100644 --- a/src/splunk_ao/utils/singleton.py +++ b/src/splunk_ao/utils/singleton.py @@ -24,7 +24,7 @@ class SplunkAOLoggerSingleton: _instance = None # Class-level attribute to hold the singleton instance. _lock = threading.Lock() # Lock for thread-safe instantiation and operations. - _galileo_loggers: ClassVar[dict[tuple[str, ...], SplunkAOLogger]] = {} # Cache for loggers. + _splunk_ao_loggers: ClassVar[dict[tuple[str, ...], SplunkAOLogger]] = {} # Cache for loggers. def __new__(cls) -> "SplunkAOLoggerSingleton": """ @@ -40,7 +40,7 @@ def __new__(cls) -> "SplunkAOLoggerSingleton": if not cls._instance: # Double-checked locking. cls._instance = super().__new__(cls) # Initialize the logger dictionary in the new instance. - cls._instance._galileo_loggers = {} + cls._instance._splunk_ao_loggers = {} return cls._instance @staticmethod @@ -157,14 +157,14 @@ def get( ) # First check without acquiring lock for performance. - if key in self._galileo_loggers: - return self._galileo_loggers[key] + if key in self._splunk_ao_loggers: + return self._splunk_ao_loggers[key] # Acquire lock for thread-safe creation of new logger. with self._lock: # Double-check in case another thread created the logger while waiting. - if key in self._galileo_loggers: - return self._galileo_loggers[key] + if key in self._splunk_ao_loggers: + return self._splunk_ao_loggers[key] # Prepare initialization arguments, only including non-None values. galileo_client_init_args = { @@ -182,7 +182,7 @@ def get( # Cache the newly created logger. if logger: - self._galileo_loggers[key] = logger + self._splunk_ao_loggers[key] = logger return logger def reset( @@ -212,18 +212,18 @@ def reset( # Terminate and remove loggers matching the base key (project, log_stream, mode, experiment_id) # This will clean up all loggers including those with trace_id/span_id base_key = SplunkAOLoggerSingleton._get_key(project, log_stream, mode, experiment_id) - keys_to_remove = [k for k in self._galileo_loggers if k[: len(base_key)] == base_key] + keys_to_remove = [k for k in self._splunk_ao_loggers if k[: len(base_key)] == base_key] for key in keys_to_remove: - self._galileo_loggers[key].terminate() - del self._galileo_loggers[key] + self._splunk_ao_loggers[key].terminate() + del self._splunk_ao_loggers[key] def reset_all(self) -> None: """Reset (terminate and remove) all SplunkAOLogger instances.""" with self._lock: # Terminate and clear all logger instances. - for logger in self._galileo_loggers.values(): + for logger in self._splunk_ao_loggers.values(): logger.terminate() - self._galileo_loggers.clear() + self._splunk_ao_loggers.clear() def flush( self, @@ -256,15 +256,15 @@ def flush( # Flush loggers matching the base key (project, log_stream, mode, experiment_id) # This will flush all loggers including those with trace_id/span_id base_key = SplunkAOLoggerSingleton._get_key(project, log_stream, mode, experiment_id) - keys_to_flush = [k for k in self._galileo_loggers if k[: len(base_key)] == base_key] + keys_to_flush = [k for k in self._splunk_ao_loggers if k[: len(base_key)] == base_key] for key in keys_to_flush: - self._galileo_loggers[key].flush() + self._splunk_ao_loggers[key].flush() def flush_all(self) -> None: """Flush (upload and clear) all SplunkAOLogger instances.""" with self._lock: # Terminate and clear all logger instances. - for logger in self._galileo_loggers.values(): + for logger in self._splunk_ao_loggers.values(): logger.flush() def get_all_loggers(self) -> dict[tuple[str, ...], SplunkAOLogger]: @@ -277,4 +277,4 @@ def get_all_loggers(self) -> dict[tuple[str, ...], SplunkAOLogger]: A dictionary mapping keys to their corresponding SplunkAOLogger instances. """ # Return a shallow copy of the loggers dictionary to prevent external modifications. - return dict(self._galileo_loggers) + return dict(self._splunk_ao_loggers) diff --git a/tests/conftest.py b/tests/conftest.py index 797eea38..5040d2a4 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -35,9 +35,9 @@ # background tasks pending, which causes pytest workers to hang at exit. # Override the module constant directly so tests don't depend on a user-facing # env var or any new SDK config knob. -from splunk_ao.logger import logger as _galileo_logger_module # noqa: E402 +from splunk_ao.logger import logger as _splunk_ao_logger_module # noqa: E402 -_galileo_logger_module.DEFAULT_TERMINATE_TIMEOUT_SECONDS = 2 +_splunk_ao_logger_module.DEFAULT_TERMINATE_TIMEOUT_SECONDS = 2 import datetime # noqa: E402 import logging # noqa: E402 @@ -338,20 +338,20 @@ def rulesets(request: pytest.FixtureRequest) -> list[Ruleset]: @pytest.fixture def enable_galileo_logging(): """Temporarily enable SDK logging for tests that need to capture log output.""" - galileo_logger = logging.getLogger("splunk_ao") - original_level = galileo_logger.level - original_propagate = galileo_logger.propagate + splunk_ao_logger = logging.getLogger("splunk_ao") + original_level = splunk_ao_logger.level + original_propagate = splunk_ao_logger.propagate # Enable logging at appropriate levels for different test types - galileo_logger.setLevel(logging.DEBUG) # Most permissive for test flexibility - galileo_logger.propagate = True + splunk_ao_logger.setLevel(logging.DEBUG) # Most permissive for test flexibility + splunk_ao_logger.propagate = True try: yield finally: # Restore original settings - galileo_logger.setLevel(original_level) - galileo_logger.propagate = original_propagate + splunk_ao_logger.setLevel(original_level) + splunk_ao_logger.propagate = original_propagate # --------------------------------------------------------------------------- diff --git a/tests/test_async_base_handler.py b/tests/test_async_base_handler.py index 0f37fa13..f0d79e72 100644 --- a/tests/test_async_base_handler.py +++ b/tests/test_async_base_handler.py @@ -14,7 +14,7 @@ class TestSplunkAOAsyncBaseHandlerCallback: @patch("splunk_ao.logger.logger.LogStreams") @patch("splunk_ao.logger.logger.Projects") @patch("splunk_ao.logger.logger.Traces") - def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): + def splunk_ao_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): """Creates a mock Galileo logger for testing""" setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) @@ -22,9 +22,9 @@ def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, m return SplunkAOLogger(project="my_project", log_stream="my_log_stream") @pytest.fixture - def handler(self, galileo_logger: SplunkAOLogger) -> Generator[SplunkAOAsyncBaseHandler, None, None]: + def handler(self, splunk_ao_logger: SplunkAOLogger) -> Generator[SplunkAOAsyncBaseHandler, None, None]: """Creates a SplunkAOCallback with a mock logger""" - handler = SplunkAOAsyncBaseHandler(galileo_logger=galileo_logger, flush_on_chain_end=False) + handler = SplunkAOAsyncBaseHandler(splunk_ao_logger=splunk_ao_logger, flush_on_chain_end=False) # Reset the root node before each test handler._root_node = None yield handler @@ -32,18 +32,18 @@ def handler(self, galileo_logger: SplunkAOLogger) -> Generator[SplunkAOAsyncBase handler._root_node = None @pytest.mark.asyncio - async def test_initialization(self, galileo_logger: SplunkAOLogger) -> None: + async def test_initialization(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test callback initialization with various parameters""" # Default initialization - callback = SplunkAOAsyncBaseHandler(galileo_logger=galileo_logger) - assert callback._galileo_logger == galileo_logger + callback = SplunkAOAsyncBaseHandler(splunk_ao_logger=splunk_ao_logger) + assert callback._splunk_ao_logger == splunk_ao_logger assert callback._start_new_trace is True assert callback._flush_on_chain_end is True assert callback._nodes == {} # Custom initialization callback = SplunkAOAsyncBaseHandler( - galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False + splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False ) assert callback._start_new_trace is False assert callback._flush_on_chain_end is False @@ -83,7 +83,7 @@ async def test_start_node(self, handler: SplunkAOAsyncBaseHandler) -> None: assert handler._root_node.run_id == parent_id @pytest.mark.asyncio - async def test_end_node(self, handler: SplunkAOAsyncBaseHandler, galileo_logger: SplunkAOLogger) -> None: + async def test_end_node(self, handler: SplunkAOAsyncBaseHandler, splunk_ao_logger: SplunkAOLogger) -> None: """Test ending a node and updating its parameters""" # Create a node run_id = uuid.uuid4() @@ -94,7 +94,7 @@ async def test_end_node(self, handler: SplunkAOAsyncBaseHandler, galileo_logger: # End the node and commit the trace await handler.async_end_node(run_id, output='{"result": "test result"}') - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Test Chain" diff --git a/tests/test_base_handler.py b/tests/test_base_handler.py index 56cc54d9..79eaadcf 100644 --- a/tests/test_base_handler.py +++ b/tests/test_base_handler.py @@ -14,7 +14,7 @@ class TestSplunkAOBaseHandler: @patch("splunk_ao.logger.logger.LogStreams") @patch("splunk_ao.logger.logger.Projects") @patch("splunk_ao.logger.logger.Traces") - def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): + def splunk_ao_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): """Creates a mock Galileo logger for testing""" setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) @@ -22,23 +22,23 @@ def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, m return SplunkAOLogger(project="my_project", log_stream="my_log_stream") @pytest.fixture - def handler(self, galileo_logger: SplunkAOLogger) -> Generator[SplunkAOBaseHandler, None, None]: + def handler(self, splunk_ao_logger: SplunkAOLogger) -> Generator[SplunkAOBaseHandler, None, None]: """Creates a SplunkAOBaseHandler with a mock logger""" - return SplunkAOBaseHandler(galileo_logger=galileo_logger, flush_on_chain_end=False) + return SplunkAOBaseHandler(splunk_ao_logger=splunk_ao_logger, flush_on_chain_end=False) # Reset the root node before each test # Clean up after each test - def test_initialization(self, galileo_logger: SplunkAOLogger) -> None: + def test_initialization(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test callback initialization with various parameters""" # Default initialization - handler = SplunkAOBaseHandler(galileo_logger=galileo_logger) - assert handler._galileo_logger == galileo_logger + handler = SplunkAOBaseHandler(splunk_ao_logger=splunk_ao_logger) + assert handler._splunk_ao_logger == splunk_ao_logger assert handler._start_new_trace is True assert handler._flush_on_chain_end is True assert handler._nodes == {} # Custom initialization - handler = SplunkAOBaseHandler(galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False) + handler = SplunkAOBaseHandler(splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False) assert handler._start_new_trace is False assert handler._flush_on_chain_end is False @@ -75,7 +75,7 @@ def test_start_node(self, handler: SplunkAOBaseHandler) -> None: assert handler._root_node assert handler._root_node.run_id == parent_id - def test_end_node(self, handler: SplunkAOBaseHandler, galileo_logger: SplunkAOLogger) -> None: + def test_end_node(self, handler: SplunkAOBaseHandler, splunk_ao_logger: SplunkAOLogger) -> None: """Test ending a node and updating its parameters""" # Create a node run_id = uuid.uuid4() @@ -86,7 +86,7 @@ def test_end_node(self, handler: SplunkAOBaseHandler, galileo_logger: SplunkAOLo # End the node and commit the trace handler.end_node(run_id, output='{"result": "test result"}') - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Test Chain" @@ -103,7 +103,7 @@ def test_commit_calls_flush(self) -> None: mock_logger.current_parent = Mock(return_value=None) mock_logger.add_workflow_span = Mock() mock_logger._set_current_parent = Mock() - handler = SplunkAOBaseHandler(galileo_logger=mock_logger, flush_on_chain_end=True) + handler = SplunkAOBaseHandler(splunk_ao_logger=mock_logger, flush_on_chain_end=True) # Setup a simple trace to commit run_id = uuid.uuid4() @@ -125,7 +125,7 @@ def test_commit_no_flush_when_disabled(self) -> None: mock_logger.current_parent = Mock(return_value=None) mock_logger.add_workflow_span = Mock() mock_logger._set_current_parent = Mock() - handler = SplunkAOBaseHandler(galileo_logger=mock_logger, flush_on_chain_end=False) + handler = SplunkAOBaseHandler(splunk_ao_logger=mock_logger, flush_on_chain_end=False) # Setup a simple trace to commit run_id = uuid.uuid4() diff --git a/tests/test_crewai_handler.py b/tests/test_crewai_handler.py index 6c37f39e..c525c767 100644 --- a/tests/test_crewai_handler.py +++ b/tests/test_crewai_handler.py @@ -77,7 +77,7 @@ def __init__(self, raw="Test output"): @pytest.fixture -def mock_galileo_logger(): +def mock_splunk_ao_logger(): """Creates a mock Galileo logger for testing.""" with ( patch("splunk_ao.logger.logger.LogStreams") as mock_logstreams, @@ -94,7 +94,7 @@ def mock_galileo_logger(): @pytest.fixture -def crewai_callback(mock_galileo_logger): +def crewai_callback(mock_splunk_ao_logger): """Creates a CrewAIEventListener instance for testing.""" with ( patch("splunk_ao.handlers.crewai.handler._crewai_imports_resolved", True), @@ -104,11 +104,11 @@ def crewai_callback(mock_galileo_logger): from splunk_ao.handlers.crewai.handler import CrewAIEventListener return CrewAIEventListener( - galileo_logger=mock_galileo_logger, start_new_trace=True, flush_on_crew_completed=False + splunk_ao_logger=mock_splunk_ao_logger, start_new_trace=True, flush_on_crew_completed=False ) -def test_initialization_with_crewai_available(mock_galileo_logger) -> None: +def test_initialization_with_crewai_available(mock_splunk_ao_logger) -> None: """Test CrewAIEventListener initialization when CrewAI is available.""" with ( patch("splunk_ao.handlers.crewai.handler._crewai_imports_resolved", True), @@ -118,15 +118,15 @@ def test_initialization_with_crewai_available(mock_galileo_logger) -> None: from splunk_ao.handlers.crewai.handler import CrewAIEventListener callback = CrewAIEventListener( - galileo_logger=mock_galileo_logger, start_new_trace=False, flush_on_crew_completed=True + splunk_ao_logger=mock_splunk_ao_logger, start_new_trace=False, flush_on_crew_completed=True ) - assert callback._handler._galileo_logger == mock_galileo_logger + assert callback._handler._splunk_ao_logger == mock_splunk_ao_logger assert callback._handler._start_new_trace is False assert callback._handler._flush_on_chain_end is True -def test_initialization_with_crewai_unavailable(mock_galileo_logger) -> None: +def test_initialization_with_crewai_unavailable(mock_splunk_ao_logger) -> None: """Test CrewAIEventListener initialization when CrewAI is unavailable.""" with ( patch("splunk_ao.handlers.crewai.handler._crewai_imports_resolved", True), @@ -135,9 +135,9 @@ def test_initialization_with_crewai_unavailable(mock_galileo_logger) -> None: ): from splunk_ao.handlers.crewai.handler import CrewAIEventListener - callback = CrewAIEventListener(galileo_logger=mock_galileo_logger) + callback = CrewAIEventListener(splunk_ao_logger=mock_splunk_ao_logger) - assert callback._handler._galileo_logger == mock_galileo_logger + assert callback._handler._splunk_ao_logger == mock_splunk_ao_logger def test_generate_run_id_with_source_id(crewai_callback) -> None: diff --git a/tests/test_experiments.py b/tests/test_experiments.py index 1fc4907e..1ca5fc97 100644 --- a/tests/test_experiments.py +++ b/tests/test_experiments.py @@ -917,7 +917,7 @@ def test_run_experiment_with_func( ) mock_get_dataset_instance.get_content.assert_called() - # check galileo_logger + # check splunk_ao_logger payload = mock_traces_client_instance.ingest_traces.call_args[0][0] assert len(payload.traces) == 1 @@ -1219,7 +1219,7 @@ def runner(input) -> str: ) mock_get_dataset_instance.get_content.assert_called() - # check galileo_logger + # check splunk_ao_logger payload = mock_core_api_instance.ingest_traces.call_args[0][0] assert len(payload.traces) == 1 assert ( diff --git a/tests/test_langchain.py b/tests/test_langchain.py index 742f5325..d97343f2 100644 --- a/tests/test_langchain.py +++ b/tests/test_langchain.py @@ -27,7 +27,7 @@ class TestSplunkAOCallback: @patch("splunk_ao.logger.logger.LogStreams") @patch("splunk_ao.logger.logger.Projects") @patch("splunk_ao.logger.logger.Traces") - def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): + def splunk_ao_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): """Creates a mock Galileo logger for testing""" setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) @@ -35,27 +35,27 @@ def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, m return SplunkAOLogger(project="my_project", log_stream="my_log_stream") @pytest.fixture - def callback(self, galileo_logger: SplunkAOLogger) -> Generator[SplunkAOCallback, None, None]: + def callback(self, splunk_ao_logger: SplunkAOLogger) -> Generator[SplunkAOCallback, None, None]: """Creates a SplunkAOCallback with a mock logger""" - return SplunkAOCallback(galileo_logger=galileo_logger, flush_on_chain_end=False) + return SplunkAOCallback(splunk_ao_logger=splunk_ao_logger, flush_on_chain_end=False) # Reset the root node before each test # Clean up after each test - def test_initialization(self, galileo_logger: SplunkAOLogger) -> None: + def test_initialization(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test callback initialization with various parameters""" # Default initialization - callback = SplunkAOCallback(galileo_logger=galileo_logger) - assert callback._handler._galileo_logger == galileo_logger + callback = SplunkAOCallback(splunk_ao_logger=splunk_ao_logger) + assert callback._handler._splunk_ao_logger == splunk_ao_logger assert callback._handler._start_new_trace is True assert callback._handler._flush_on_chain_end is True assert callback._handler._nodes == {} # Custom initialization - callback = SplunkAOCallback(galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False) + callback = SplunkAOCallback(splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False) assert callback._handler._start_new_trace is False assert callback._handler._flush_on_chain_end is False - def test_on_chain_start_end(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_on_chain_start_end(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test chain start and end callbacks""" run_id = uuid.uuid4() @@ -71,7 +71,7 @@ def test_on_chain_start_end(self, callback: SplunkAOCallback, galileo_logger: Sp # End chain callback.on_chain_end(outputs='{"result": "test answer"}', run_id=run_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "TestChain" @@ -81,7 +81,7 @@ def test_on_chain_start_end(self, callback: SplunkAOCallback, galileo_logger: Sp assert traces[0].spans[0].step_number is None def test_on_chain_start_with_kwargs_serialised_none( - self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger ) -> None: run_id = uuid.uuid4() @@ -112,7 +112,7 @@ def test_on_chain_start_with_kwargs_serialised_none( # End chain callback.on_chain_end(outputs='{"result": "test answer"}', run_id=run_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Agent" @@ -124,7 +124,7 @@ def test_on_chain_start_with_kwargs_serialised_none( assert traces[0].spans[0].output == '{"result": "test answer"}' assert traces[0].spans[0].step_number is None - def test_on_agent_chain(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_on_agent_chain(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test agent chain handling""" run_id = uuid.uuid4() @@ -140,7 +140,7 @@ def test_on_agent_chain(self, callback: SplunkAOCallback, galileo_logger: Splunk callback.on_agent_finish(finish=finish, run_id=run_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Agent" @@ -233,7 +233,7 @@ def test_on_chat_model_start(self, callback: SplunkAOCallback) -> None: assert input_data[2]["role"] == "assistant" def test_on_chat_model_start_end_with_tools( - self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test chat model start and end callbacks with tools""" run_id = uuid.uuid4() @@ -292,7 +292,7 @@ def test_on_chat_model_start_end_with_tools( callback.on_llm_end(response=llm_response, run_id=run_id, parent_run_id=chain_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Chat" @@ -471,7 +471,7 @@ def test_on_retriever_start_end(self, callback: SplunkAOCallback) -> None: assert len(node.span_params["output"]) == 1 def test_extracting_chain_names_from_metadata( - self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test extracting chain names from metadata kwarg, with two nested chains""" chain_id = uuid.uuid4() @@ -493,7 +493,7 @@ def test_extracting_chain_names_from_metadata( callback.on_chain_end(outputs={"result": "test"}, run_id=chain_id2) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 @@ -503,7 +503,7 @@ def test_extracting_chain_names_from_metadata( assert len(traces[0].spans[0].spans) == 1 assert traces[0].spans[0].spans[0].name == "Test Chain 2" - def test_complex_execution_flow(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_complex_execution_flow(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test a complex execution flow with multiple component types""" # Create UUIDs for different components chain_id = uuid.uuid4() @@ -571,7 +571,7 @@ def test_complex_execution_flow(self, callback: SplunkAOCallback, galileo_logger run_id=chain_id, ) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 # 1 workflow span assert len(traces[0].spans[0].spans) == 3 # 3 child spans @@ -689,14 +689,14 @@ def test_get_node_name(self, callback: SplunkAOCallback) -> None: result = callback._get_node_name("chain", "not_a_dict") assert result == "Chain" # Should capitalize the node_type - def test_callback_with_active_trace(self, galileo_logger: SplunkAOLogger) -> None: + def test_callback_with_active_trace(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test that the callback properly handles an active trace.""" run_id = uuid.uuid4() - galileo_logger.start_trace(input="test input") + splunk_ao_logger.start_trace(input="test input") # Pass the active logger to the callback - callback = SplunkAOCallback(galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False) + callback = SplunkAOCallback(splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False) # Start a chain (creates a workflow span) callback._handler.start_node("chain", None, run_id, name="Test Chain", input='{"query": "test"}') @@ -711,9 +711,9 @@ def test_callback_with_active_trace(self, galileo_logger: SplunkAOLogger) -> Non # End the chain (ends the workflow span) callback._handler.end_node(run_id, output='{"result": "test result"}') - galileo_logger.conclude(output="test output", status_code=200) + splunk_ao_logger.conclude(output="test output", status_code=200) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 @@ -725,7 +725,7 @@ def test_callback_with_active_trace(self, galileo_logger: SplunkAOLogger) -> Non assert traces[0].spans[0].spans[0].input == "test query" assert traces[0].spans[0].spans[0].output == [GalileoDocument(content="test document", metadata={})] - def test_node_created_at(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_node_created_at(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: parent_id = uuid.uuid4() llm_run_id = uuid.uuid4() retriever_run_id = uuid.uuid4() @@ -768,7 +768,7 @@ def test_node_created_at(self, callback: SplunkAOCallback, galileo_logger: Splun # End chain callback.on_chain_end(outputs='{"result": "test answer"}', run_id=parent_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert len(traces[0].spans[0].spans) == 2 @@ -827,7 +827,7 @@ def test_node_created_at(self, callback: SplunkAOCallback, galileo_logger: Splun def test_step_number_propagation( self, callback: SplunkAOCallback, - galileo_logger: SplunkAOLogger, + splunk_ao_logger: SplunkAOLogger, node_type, start_fn, end_fn, @@ -859,21 +859,21 @@ def test_step_number_propagation( # End chain to trigger commit for non-root nodes if node_type not in ("chain", "agent"): callback.on_chain_end(outputs={"result": "test answer"}, run_id=parent_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 child_span = traces[0].spans[0].spans[0] assert child_span.type == expected_type assert child_span.step_number == step_number else: - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 root_span = traces[0].spans[0] assert root_span.type == expected_type assert root_span.step_number == step_number - def test_on_nested_agent_chains(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_on_nested_agent_chains(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test nested agent chain handling and name change""" outer_run_id = uuid.uuid4() inner_run_id = uuid.uuid4() @@ -892,7 +892,7 @@ def test_on_nested_agent_chains(self, callback: SplunkAOCallback, galileo_logger callback.on_agent_finish(finish=inner_finish, run_id=inner_run_id) callback.on_chain_end(outputs={"output": "outer result"}, run_id=outer_run_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 outer_span = traces[0].spans[0] @@ -903,7 +903,7 @@ def test_on_nested_agent_chains(self, callback: SplunkAOCallback, galileo_logger assert inner_span.type == "agent" assert inner_span.name == "OuterChain:Agent" - def test_ai_message_with_list_content(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_ai_message_with_list_content(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test AIMessage serialization with content as list of dicts (Responses API format)""" run_id = uuid.uuid4() parent_id = uuid.uuid4() @@ -934,7 +934,7 @@ def test_ai_message_with_list_content(self, callback: SplunkAOCallback, galileo_ assert input_data[0]["role"] == "assistant" assert input_data[0]["content"] == [{"type": "text", "text": "This is a response from the Responses API"}] - def test_ai_message_with_reasoning(self, callback: SplunkAOCallback, galileo_logger: SplunkAOLogger) -> None: + def test_ai_message_with_reasoning(self, callback: SplunkAOCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test AIMessage serialization with reasoning in additional_kwargs""" run_id = uuid.uuid4() parent_id = uuid.uuid4() @@ -1036,8 +1036,8 @@ def logger_mocks(self): "callback_builder", [ lambda hook: SplunkAOCallback(ingestion_hook=hook), - lambda hook: SplunkAOCallback(galileo_logger=SplunkAOLogger(), ingestion_hook=hook), - lambda hook: SplunkAOCallback(galileo_logger=splunk_ao_context.get_logger_instance(), ingestion_hook=hook), + lambda hook: SplunkAOCallback(splunk_ao_logger=SplunkAOLogger(), ingestion_hook=hook), + lambda hook: SplunkAOCallback(splunk_ao_logger=splunk_ao_context.get_logger_instance(), ingestion_hook=hook), ], ) def test_on_chain_end_with_ingestion_hook(self, callback_builder): @@ -1335,7 +1335,7 @@ def test_callback_with_ingestion_hook_no_credentials(self): callback = SplunkAOCallback(ingestion_hook=mock_hook) # Then: the callback is created successfully and the hook is attached - assert callback._handler._galileo_logger._ingestion_hook is mock_hook + assert callback._handler._splunk_ao_logger._ingestion_hook is mock_hook def test_async_callback_with_ingestion_hook_no_credentials(self): """SplunkAOAsyncCallback(ingestion_hook=...) should not require API credentials.""" @@ -1346,4 +1346,4 @@ def test_async_callback_with_ingestion_hook_no_credentials(self): callback = SplunkAOAsyncCallback(ingestion_hook=mock_hook) # Then: the callback is created successfully and the hook is attached - assert callback._handler._galileo_logger._ingestion_hook is mock_hook + assert callback._handler._splunk_ao_logger._ingestion_hook is mock_hook diff --git a/tests/test_langchain_async.py b/tests/test_langchain_async.py index 1891e7e6..ce69f066 100644 --- a/tests/test_langchain_async.py +++ b/tests/test_langchain_async.py @@ -24,7 +24,7 @@ class TestSplunkAOAsyncCallback: @patch("splunk_ao.logger.logger.LogStreams") @patch("splunk_ao.logger.logger.Projects") @patch("splunk_ao.logger.logger.Traces") - def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): + def splunk_ao_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): """Creates a mock Galileo logger for testing""" setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) @@ -32,27 +32,27 @@ def galileo_logger(self, mock_traces_client: Mock, mock_projects_client: Mock, m return SplunkAOLogger(project="my_project", log_stream="my_log_stream") @pytest.fixture - def callback(self, galileo_logger: SplunkAOLogger) -> Generator[SplunkAOAsyncCallback, None, None]: + def callback(self, splunk_ao_logger: SplunkAOLogger) -> Generator[SplunkAOAsyncCallback, None, None]: """Creates a SplunkAOCallback with a mock logger""" - return SplunkAOAsyncCallback(galileo_logger=galileo_logger, flush_on_chain_end=False) + return SplunkAOAsyncCallback(splunk_ao_logger=splunk_ao_logger, flush_on_chain_end=False) @mark.asyncio - async def test_initialization(self, galileo_logger: SplunkAOLogger) -> None: + async def test_initialization(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test callback initialization with various parameters""" # Default initialization - callback = SplunkAOAsyncCallback(galileo_logger=galileo_logger) - assert callback._handler._galileo_logger == galileo_logger + callback = SplunkAOAsyncCallback(splunk_ao_logger=splunk_ao_logger) + assert callback._handler._splunk_ao_logger == splunk_ao_logger assert callback._handler._start_new_trace is True assert callback._handler._flush_on_chain_end is True assert callback._handler._nodes == {} # Custom initialization - callback = SplunkAOAsyncCallback(galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False) + callback = SplunkAOAsyncCallback(splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False) assert callback._handler._start_new_trace is False assert callback._handler._flush_on_chain_end is False @mark.asyncio - async def test_on_chain_start_end(self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger) -> None: + async def test_on_chain_start_end(self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test chain start and end callbacks""" run_id = uuid.uuid4() @@ -73,7 +73,7 @@ async def test_on_chain_start_end(self, callback: SplunkAOAsyncCallback, galileo # Verify chain was properly ended # assert callback._nodes.get(str(run_id)).span_params["output"] == '{"result": "test answer"}' - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "TestChain" @@ -84,7 +84,7 @@ async def test_on_chain_start_end(self, callback: SplunkAOAsyncCallback, galileo @mark.asyncio async def test_on_chain_start_end_with_input_update( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test chain start and end callbacks with input update""" run_id = uuid.uuid4() @@ -102,7 +102,7 @@ async def test_on_chain_start_end_with_input_update( outputs='{"result": "test answer"}', run_id=run_id, inputs={"query": "test question"} ) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "TestChain" @@ -112,7 +112,7 @@ async def test_on_chain_start_end_with_input_update( assert traces[0].spans[0].step_number is None @mark.asyncio - async def test_on_agent_chain(self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger) -> None: + async def test_on_agent_chain(self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger) -> None: """Test agent chain handling""" run_id = uuid.uuid4() @@ -128,7 +128,7 @@ async def test_on_agent_chain(self, callback: SplunkAOAsyncCallback, galileo_log await callback.on_agent_finish(finish=finish, run_id=run_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Agent" @@ -223,7 +223,7 @@ async def test_on_chat_model_start(self, callback: SplunkAOAsyncCallback) -> Non @mark.asyncio async def test_on_chat_model_start_end_with_tools( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test chat model start and end callbacks with tools""" run_id = uuid.uuid4() @@ -282,7 +282,7 @@ async def test_on_chat_model_start_end_with_tools( await callback.on_llm_end(response=llm_response, run_id=run_id, parent_run_id=chain_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert traces[0].spans[0].name == "Chat" @@ -466,7 +466,7 @@ async def test_on_retriever_start_end(self, callback: SplunkAOAsyncCallback) -> @mark.asyncio async def test_extracting_chain_names_from_metadata( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test extracting chain names from metadata kwarg, with two nested chains""" chain_id = uuid.uuid4() @@ -488,7 +488,7 @@ async def test_extracting_chain_names_from_metadata( await callback.on_chain_end(outputs={"result": "test"}, run_id=chain_id2) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 @@ -500,7 +500,7 @@ async def test_extracting_chain_names_from_metadata( @mark.asyncio async def test_complex_execution_flow( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test a complex execution flow with multiple component types""" # Create UUIDs for different components @@ -569,7 +569,7 @@ async def test_complex_execution_flow( run_id=chain_id, ) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 # 1 workflow span assert len(traces[0].spans[0].spans) == 3 # 3 child spans @@ -655,14 +655,14 @@ def __repr__(self): assert isinstance(node.span_params["output"], str) @mark.asyncio - async def test_callback_with_active_trace(self, galileo_logger: SplunkAOLogger) -> None: + async def test_callback_with_active_trace(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test that the callback properly handles an active trace.""" run_id = uuid.uuid4() - galileo_logger.start_trace(input="test input") + splunk_ao_logger.start_trace(input="test input") # Pass the active logger to the callback - callback = SplunkAOAsyncCallback(galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False) + callback = SplunkAOAsyncCallback(splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False) # Start a chain (creates a workflow span) await callback._handler.async_start_node("chain", None, run_id, name="Test Chain", input='{"query": "test"}') @@ -677,9 +677,9 @@ async def test_callback_with_active_trace(self, galileo_logger: SplunkAOLogger) # End the chain (ends the workflow span) await callback._handler.async_end_node(run_id, output='{"result": "test result"}') - galileo_logger.conclude(output="test output", status_code=200) + splunk_ao_logger.conclude(output="test output", status_code=200) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 @@ -693,7 +693,7 @@ async def test_callback_with_active_trace(self, galileo_logger: SplunkAOLogger) assert traces[0].spans[0].step_number is None @mark.asyncio - async def test_node_created_at(self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger) -> None: + async def test_node_created_at(self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger) -> None: parent_id = uuid.uuid4() llm_run_id = uuid.uuid4() retriever_run_id = uuid.uuid4() @@ -736,7 +736,7 @@ async def test_node_created_at(self, callback: SplunkAOAsyncCallback, galileo_lo # End chain await callback.on_chain_end(outputs='{"result": "test answer"}', run_id=parent_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 assert len(traces[0].spans[0].spans) == 2 @@ -796,7 +796,7 @@ async def test_node_created_at(self, callback: SplunkAOAsyncCallback, galileo_lo async def test_step_number_propagation( self, callback: SplunkAOAsyncCallback, - galileo_logger: SplunkAOLogger, + splunk_ao_logger: SplunkAOLogger, node_type, start_fn, end_fn, @@ -828,14 +828,14 @@ async def test_step_number_propagation( # End chain to trigger commit for non-root nodes if node_type not in ("chain", "agent"): await callback.on_chain_end(outputs={"result": "test answer"}, run_id=parent_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 child_span = traces[0].spans[0].spans[0] assert child_span.type == expected_type assert child_span.step_number == step_number else: - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 root_span = traces[0].spans[0] @@ -844,7 +844,7 @@ async def test_step_number_propagation( @mark.asyncio async def test_on_nested_agent_chains( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test nested agent chain handling and name change""" outer_run_id = uuid.uuid4() @@ -866,7 +866,7 @@ async def test_on_nested_agent_chains( await callback.on_agent_finish(finish=inner_finish, run_id=inner_run_id) await callback.on_chain_end(outputs={"output": "outer result"}, run_id=outer_run_id) - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 assert len(traces[0].spans) == 1 outer_span = traces[0].spans[0] @@ -879,7 +879,7 @@ async def test_on_nested_agent_chains( @mark.asyncio async def test_ai_message_with_list_content( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test AIMessage serialization with content as list of dicts (Responses API format)""" run_id = uuid.uuid4() @@ -913,7 +913,7 @@ async def test_ai_message_with_list_content( @mark.asyncio async def test_ai_message_with_reasoning( - self, callback: SplunkAOAsyncCallback, galileo_logger: SplunkAOLogger + self, callback: SplunkAOAsyncCallback, splunk_ao_logger: SplunkAOLogger ) -> None: """Test AIMessage serialization with reasoning in additional_kwargs""" run_id = uuid.uuid4() @@ -956,15 +956,15 @@ async def test_ai_message_with_reasoning( assert input_data[0]["tool_calls"] == [{"id": "call_1", "function": {"name": "search", "arguments": "{}"}}] @mark.asyncio - async def test_on_chain_end_with_ingestion_hook(self, galileo_logger: SplunkAOLogger) -> None: + async def test_on_chain_end_with_ingestion_hook(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test that the ingestion hook is called on chain end.""" run_id = uuid.uuid4() mock_hook = Mock() callback = SplunkAOAsyncCallback( - galileo_logger=galileo_logger, flush_on_chain_end=True, ingestion_hook=mock_hook + splunk_ao_logger=splunk_ao_logger, flush_on_chain_end=True, ingestion_hook=mock_hook ) # Mock the underlying traces client to ensure it's not called directly - with patch.object(galileo_logger, "_traces_client") as mock_traces_client: + with patch.object(splunk_ao_logger, "_traces_client") as mock_traces_client: await callback.on_chain_start( serialized={"name": "TestChain"}, inputs='{"query": "test question"}', run_id=run_id ) diff --git a/tests/test_langchain_middleware.py b/tests/test_langchain_middleware.py index 9f1f1357..fa68996f 100644 --- a/tests/test_langchain_middleware.py +++ b/tests/test_langchain_middleware.py @@ -91,7 +91,7 @@ class RealArgsSchema(BaseModel): @patch("splunk_ao.logger.logger.LogStreams") @patch("splunk_ao.logger.logger.Projects") @patch("splunk_ao.logger.logger.Traces") -def galileo_logger(mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): +def splunk_ao_logger(mock_traces_client: Mock, mock_projects_client: Mock, mock_logstreams_client: Mock): """Creates a mock Galileo logger for testing.""" setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) @@ -100,9 +100,9 @@ def galileo_logger(mock_traces_client: Mock, mock_projects_client: Mock, mock_lo @pytest.fixture -def middleware(galileo_logger: SplunkAOLogger) -> SplunkAOMiddleware: +def middleware(splunk_ao_logger: SplunkAOLogger) -> SplunkAOMiddleware: """Creates a SplunkAOMiddleware with a mock logger.""" - return SplunkAOMiddleware(galileo_logger=galileo_logger, flush_on_chain_end=False) + return SplunkAOMiddleware(splunk_ao_logger=splunk_ao_logger, flush_on_chain_end=False) @pytest.fixture @@ -124,19 +124,19 @@ def sample_state(sample_messages): class TestSplunkAOMiddlewareInitialization: - def test_default_initialization(self, galileo_logger: SplunkAOLogger) -> None: + def test_default_initialization(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test middleware initialization with default parameters.""" - middleware = SplunkAOMiddleware(galileo_logger=galileo_logger) + middleware = SplunkAOMiddleware(splunk_ao_logger=splunk_ao_logger) - assert middleware._handler._galileo_logger == galileo_logger - assert middleware._async_handler._galileo_logger == galileo_logger + assert middleware._handler._splunk_ao_logger == splunk_ao_logger + assert middleware._async_handler._splunk_ao_logger == splunk_ao_logger assert middleware._handler._start_new_trace is True assert middleware._handler._flush_on_chain_end is True assert middleware._root_run_id is None - def test_custom_initialization(self, galileo_logger: SplunkAOLogger) -> None: + def test_custom_initialization(self, splunk_ao_logger: SplunkAOLogger) -> None: """Test middleware initialization with custom parameters.""" - middleware = SplunkAOMiddleware(galileo_logger=galileo_logger, start_new_trace=False, flush_on_chain_end=False) + middleware = SplunkAOMiddleware(splunk_ao_logger=splunk_ao_logger, start_new_trace=False, flush_on_chain_end=False) assert middleware._handler._start_new_trace is False assert middleware._handler._flush_on_chain_end is False @@ -507,8 +507,8 @@ def logger_mocks(self): "middleware_builder", [ lambda hook: SplunkAOMiddleware(ingestion_hook=hook), - lambda hook: SplunkAOMiddleware(galileo_logger=SplunkAOLogger(), ingestion_hook=hook), - lambda hook: SplunkAOMiddleware(galileo_logger=splunk_ao_context.get_logger_instance(), ingestion_hook=hook), + lambda hook: SplunkAOMiddleware(splunk_ao_logger=SplunkAOLogger(), ingestion_hook=hook), + lambda hook: SplunkAOMiddleware(splunk_ao_logger=splunk_ao_context.get_logger_instance(), ingestion_hook=hook), ], ) def test_ingestion_hook_called(self, middleware_builder) -> None: diff --git a/tests/test_logger_batch.py b/tests/test_logger_batch.py index 82d413a2..65f59191 100644 --- a/tests/test_logger_batch.py +++ b/tests/test_logger_batch.py @@ -42,7 +42,7 @@ LOGGER = logging.getLogger(__name__) -def test_galileo_logger_exceptions() -> None: +def test_splunk_ao_logger_exceptions() -> None: with pytest.raises(Exception) as exc_info: SplunkAOLogger(project="my_project", log_stream="my_log_stream", experiment_id="my_experiment_id") assert str(exc_info.value) == "User cannot specify both a log stream and an experiment." @@ -55,7 +55,7 @@ def test_galileo_logger_exceptions() -> None: @patch("splunk_ao.logger.logger.Traces") -def test_disable_galileo_logger(mock_traces_client: Mock, monkeypatch, caplog, enable_galileo_logging) -> None: +def test_disable_splunk_ao_logger(mock_traces_client: Mock, monkeypatch, caplog, enable_galileo_logging) -> None: monkeypatch.setenv("SPLUNK_AO_LOGGING_DISABLED", "true") with caplog.at_level(logging.DEBUG): @@ -985,7 +985,7 @@ def test_flush_workflow_keeps_message_trace_gets_string( @patch("splunk_ao.logger.logger.Projects.get") @patch("splunk_ao.projects.create_project_projects_post") @patch("splunk_ao.logger.logger.Traces") -def test_galileo_logger_failed_creating_project( +def test_splunk_ao_logger_failed_creating_project( mock_traces_client: Mock, galileo_resources_api_projects: Mock, mock_projects_get: Mock ) -> None: """Test that SplunkAOLogger raises ValueError when project creation fails.""" diff --git a/tests/test_logger_distributed.py b/tests/test_logger_distributed.py index 7af8963d..d0c7be07 100644 --- a/tests/test_logger_distributed.py +++ b/tests/test_logger_distributed.py @@ -26,14 +26,14 @@ LOGGER = logging.getLogger(__name__) -def test_galileo_logger_exceptions() -> None: +def test_splunk_ao_logger_exceptions() -> None: with pytest.raises(Exception) as exc_info: SplunkAOLogger(project="my_project", log_stream="my_log_stream", experiment_id="my_experiment_id") assert str(exc_info.value) == "User cannot specify both a log stream and an experiment." @patch("splunk_ao.logger.logger.Traces") -def test_disable_galileo_logger(mock_traces_client: Mock, monkeypatch, caplog) -> None: +def test_disable_splunk_ao_logger(mock_traces_client: Mock, monkeypatch, caplog) -> None: monkeypatch.setenv("SPLUNK_AO_LOGGING_DISABLED", "true") with caplog.at_level(logging.WARNING): diff --git a/tests/test_openai_agents.py b/tests/test_openai_agents.py index d4d5ef36..fdc3e03a 100644 --- a/tests/test_openai_agents.py +++ b/tests/test_openai_agents.py @@ -80,8 +80,8 @@ async def test_complex_agent( setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) setup_mock_logstreams_client(mock_logstreams_client) - galileo_logger = SplunkAOLogger(project="test", log_stream="test") - gp = SplunkAOTracingProcessor(galileo_logger=galileo_logger, flush_on_trace_end=False) + splunk_ao_logger = SplunkAOLogger(project="test", log_stream="test") + gp = SplunkAOTracingProcessor(splunk_ao_logger=splunk_ao_logger, flush_on_trace_end=False) set_trace_processors([gp]) monkeypatch.setenv("OPENAI_API_KEY", "sk-test") @@ -89,7 +89,7 @@ async def test_complex_agent( await Runner.run(triage_agent, "who was the first president of the united states?") await Runner.run(triage_agent, "what is life") - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 2 spans = traces[0].spans assert len(spans) == 2 @@ -111,14 +111,14 @@ async def test_simple_agent( mock_traces_client_instance = setup_mock_traces_client(mock_traces_client) setup_mock_projects_client(mock_projects_client) setup_mock_logstreams_client(mock_logstreams_client) - galileo_logger = SplunkAOLogger(project="test", log_stream="test") - gp = SplunkAOTracingProcessor(galileo_logger=galileo_logger, flush_on_trace_end=False) + splunk_ao_logger = SplunkAOLogger(project="test", log_stream="test") + gp = SplunkAOTracingProcessor(splunk_ao_logger=splunk_ao_logger, flush_on_trace_end=False) set_trace_processors([gp]) monkeypatch.setenv("OPENAI_API_KEY", "sk-test") agent = Agent(name="Assistant", instructions="You are the worlds best assistant.") result = await Runner.run(agent, "Write a haiku about recursion in programming.") assert result - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 trace = traces[0] for span in trace.spans: @@ -126,7 +126,7 @@ async def test_simple_agent( assert span.metrics.duration_ns assert span.metrics.duration_ns > 0 - galileo_logger.flush() + splunk_ao_logger.flush() payload = mock_traces_client_instance.ingest_traces.call_args[0][0] assert len(payload.traces) == 1 assert len(payload.traces[0].spans) == 1 @@ -209,8 +209,8 @@ async def test_pre_built_tools_multiple_types( setup_mock_projects_client(mock_projects_client) setup_mock_logstreams_client(mock_logstreams_client) - galileo_logger = SplunkAOLogger(project="test", log_stream="test") - gp = SplunkAOTracingProcessor(galileo_logger=galileo_logger, flush_on_trace_end=False) + splunk_ao_logger = SplunkAOLogger(project="test", log_stream="test") + gp = SplunkAOTracingProcessor(splunk_ao_logger=splunk_ao_logger, flush_on_trace_end=False) set_trace_processors([gp]) monkeypatch.setenv("OPENAI_API_KEY", "sk-test") @@ -251,7 +251,7 @@ async def test_pre_built_tools_multiple_types( result = await Runner.run(agent, "Test multiple tools.") assert result - traces = galileo_logger.traces + traces = splunk_ao_logger.traces assert len(traces) == 1 llm_spans = _find_llm_spans(traces[0].spans) @@ -295,7 +295,7 @@ async def test_pre_built_tools_multiple_types( assert len(spans_with_tools) > 0, "Expected at least one LLM span with tools" - galileo_logger.flush() + splunk_ao_logger.flush() payload = mock_traces_client_instance.ingest_traces.call_args[0][0] assert len(payload.traces) == 1 diff --git a/tests/test_openai_agents_utils.py b/tests/test_openai_agents_utils.py index 7ef33611..69b1bdc0 100644 --- a/tests/test_openai_agents_utils.py +++ b/tests/test_openai_agents_utils.py @@ -299,7 +299,7 @@ def test_span_data_types(self, span_data: Any, expected_type: str) -> None: def test_galileo_custom_span(self) -> None: """Test mapping SplunkAOCustomSpan.""" galileo_span = WorkflowSpan(name="Test", input="input", output="output", status_code=200) - assert _map_span_type(SplunkAOCustomSpan(galileo_span, {})) == "galileo_custom" + assert _map_span_type(SplunkAOCustomSpan(galileo_span, {})) == "splunk_ao_custom" @pytest.mark.parametrize( "type_attr,expected_type", [("function", "tool"), ("generation", "llm"), ("agent", "workflow")] @@ -325,7 +325,7 @@ class TestSplunkAOCustomSpan: ) def test_wraps_span_types(self, span: Any) -> None: """Test that SplunkAOCustomSpan wraps different span types.""" - assert SplunkAOCustomSpan(span, {}).type == "galileo_custom" + assert SplunkAOCustomSpan(span, {}).type == "splunk_ao_custom" def test_preserves_underlying_properties(self) -> None: """Test accessing underlying span properties."""