fix(handlers): pass ingestion_hook through handler → logger chain (#479)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: fernandocorreia-galileo

src/galileo/decorator.py

@@ -978,6 +978,7 @@ def get_logger_instance(
         log_stream: Optional[str] = None,
         experiment_id: Optional[str] = None,
         mode: Optional[str] = None,
+        ingestion_hook: Optional[Callable] = None,
     ) -> GalileoLogger:
         """
         Get the Galileo Logger instance for the current decorator context.
@@ -1009,6 +1010,8 @@ def get_logger_instance(
             kwargs["trace_id"] = trace_id_from_context
         if span_id_from_context:
             kwargs["span_id"] = span_id_from_context
+        if ingestion_hook is not None:
+            kwargs["ingestion_hook"] = ingestion_hook
 
         return GalileoLoggerSingleton().get(**kwargs)
 

src/galileo/handlers/base_handler.py

@@ -43,8 +43,12 @@ def __init__(
         flush_on_chain_end: bool = True,
         ingestion_hook: Optional[Callable[[TracesIngestRequest], None]] = None,
     ):
-        self._galileo_logger: GalileoLogger = galileo_logger or galileo_context.get_logger_instance()
-        if ingestion_hook:
+        self._galileo_logger: GalileoLogger = galileo_logger or galileo_context.get_logger_instance(
+            ingestion_hook=ingestion_hook
+        )
+        if galileo_logger and ingestion_hook:
+            if self._galileo_logger.mode == "distributed":
+                raise ValueError("ingestion_hook can only be used in batch mode")
             self._galileo_logger._ingestion_hook = ingestion_hook
         self._start_new_trace: bool = start_new_trace
         self._flush_on_chain_end: bool = flush_on_chain_end

src/galileo/utils/singleton.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import ClassVar, Optional
+from typing import Callable, ClassVar, Optional
 
 from galileo.logger import GalileoLogger
 from galileo.schema.metrics import LocalMetricConfig
@@ -50,6 +50,7 @@ def _get_key(
         experiment_id: Optional[str] = None,
         trace_id: Optional[str] = None,
         span_id: Optional[str] = None,
+        ingestion_hook_id: Optional[int] = None,
     ) -> tuple[str, ...]:
         """
         Generate a key tuple based on project, log_stream, and tracing parameters.
@@ -99,6 +100,8 @@ def _get_key(
             base_key = (*base_key, trace_id)
         if span_id is not None:
             base_key = (*base_key, span_id)
+        if ingestion_hook_id is not None:
+            base_key = (*base_key, str(ingestion_hook_id))
 
         return base_key
 
@@ -112,6 +115,7 @@ def get(
         local_metrics: Optional[list[LocalMetricConfig]] = None,
         trace_id: Optional[str] = None,
         span_id: Optional[str] = None,
+        ingestion_hook: Optional[Callable] = None,
     ) -> GalileoLogger:
         """
         Retrieve an existing GalileoLogger or create a new one if it does not exist.
@@ -141,7 +145,15 @@ def get(
         mode = _get_mode_or_default(mode)
 
         # Compute the key based on provided parameters or environment variables.
-        key = GalileoLoggerSingleton._get_key(project, log_stream, mode, experiment_id, trace_id, span_id)
+        key = GalileoLoggerSingleton._get_key(
+            project,
+            log_stream,
+            mode,
+            experiment_id,
+            trace_id,
+            span_id,
+            ingestion_hook_id=id(ingestion_hook) if ingestion_hook else None,
+        )
 
         # First check without acquiring lock for performance.
         if key in self._galileo_loggers:
@@ -162,6 +174,7 @@ def get(
                 "mode": mode,
                 "trace_id": trace_id,
                 "span_id": span_id,
+                "ingestion_hook": ingestion_hook,
             }
             # Create the logger with filtered kwargs.
             logger = GalileoLogger(**{k: v for k, v in galileo_client_init_args.items() if v is not None})

tests/test_langchain.py

@@ -1158,3 +1158,57 @@ def test_updates_with_single_langgraph_key(self) -> None:
         update_root_to_agent(parent_run_id, metadata, parent_node)
 
         assert parent_node.node_type == "agent"
+
+
+class TestGalileoCallbackIngestionHookWithoutCredentials:
+    """SC-54690: GalileoCallback/GalileoAsyncCallback with ingestion_hook should work without API credentials.
+
+    When a user provides an ingestion_hook, the handler should not require Galileo API configuration
+    (GALILEO_API_KEY, etc.) because the hook bypasses the API entirely. This test verifies the fix
+    without mocking Projects/LogStreams/Traces, so the real code path is exercised.
+    """
+
+    @pytest.fixture(autouse=True)
+    def clear_galileo_config(self, monkeypatch):
+        """Remove Galileo credentials and reset config to simulate no-API-key scenario."""
+        from galileo.config import GalileoPythonConfig
+        from galileo.utils.singleton import GalileoLoggerSingleton
+
+        # Given: no Galileo API credentials are configured
+        monkeypatch.delenv("GALILEO_API_KEY", raising=False)
+        monkeypatch.delenv("GALILEO_PROJECT", raising=False)
+        monkeypatch.delenv("GALILEO_LOG_STREAM", raising=False)
+        monkeypatch.setenv("GALILEO_CONSOLE_URL", "https://console.galileo.ai/")
+
+        if GalileoPythonConfig._instance is not None:
+            GalileoPythonConfig._instance.reset()
+
+        GalileoLoggerSingleton().reset_all()
+
+        yield
+
+        GalileoLoggerSingleton().reset_all()
+
+    def test_callback_with_ingestion_hook_no_credentials(self):
+        """GalileoCallback(ingestion_hook=...) should not require API credentials."""
+        # Given: a sync ingestion hook
+        mock_hook = Mock()
+
+        # When: creating GalileoCallback with only an ingestion hook (no pre-created logger)
+        callback = GalileoCallback(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
+
+    def test_async_callback_with_ingestion_hook_no_credentials(self):
+        """GalileoAsyncCallback(ingestion_hook=...) should not require API credentials."""
+        from galileo.handlers.langchain import GalileoAsyncCallback
+
+        # Given: an async ingestion hook
+        mock_hook = Mock()
+
+        # When: creating GalileoAsyncCallback with only an ingestion hook (no pre-created logger)
+        callback = GalileoAsyncCallback(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