chore(core): reduce streaming metadata / perf (#36588)

- looking into reducing streaming metadata / perfm

---------

Co-authored-by: William Fu-Hinthorn <13333726+hinthornw@users.noreply.github.com>

libs/core/langchain_core/tracers/core.py

@@ -51,6 +51,8 @@ class _TracerCore(ABC):
         _schema_format: Literal[
             "original", "streaming_events", "original+chat"
         ] = "original",
+        run_map: dict[str, Run] | None = None,
+        order_map: dict[UUID, tuple[UUID, str]] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the tracer.
@@ -70,6 +72,8 @@ class _TracerCore(ABC):
                     streaming events.
                 - `'original+chat'` is a format that is the same as `'original'` except
                     it does NOT raise an attribute error `on_chat_model_start`
+            run_map: Optional shared map of run ID to run.
+            order_map: Optional shared map of run ID to trace ordering data.
             **kwargs: Additional keyword arguments that will be passed to the
                 superclass.
         """
@@ -77,10 +81,10 @@ class _TracerCore(ABC):
 
         self._schema_format = _schema_format  # For internal use only API will change.
 
-        self.run_map: dict[str, Run] = {}
+        self.run_map = run_map if run_map is not None else {}
         """Map of run ID to run. Cleared on run end."""
 
-        self.order_map: dict[UUID, tuple[UUID, str]] = {}
+        self.order_map = order_map if order_map is not None else {}
         """Map of run ID to (trace_id, dotted_order). Cleared when tracer GCed."""
 
     @abstractmethod

libs/core/langchain_core/tracers/langchain.py

@@ -27,6 +27,8 @@ from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.schemas import Run
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from langchain_core.messages import BaseMessage
     from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
 
@@ -124,6 +126,8 @@ class LangChainTracer(BaseTracer):
         project_name: str | None = None,
         client: Client | None = None,
         tags: list[str] | None = None,
+        *,
+        metadata: Mapping[str, str] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the LangChain tracer.
@@ -139,6 +143,9 @@ class LangChainTracer(BaseTracer):
             tags: The tags.
 
                 Defaults to an empty list.
+            metadata: Additional metadata to include if it isn't already in the run.
+
+                Defaults to None.
             **kwargs: Additional keyword arguments.
         """
         super().__init__(**kwargs)
@@ -150,6 +157,39 @@ class LangChainTracer(BaseTracer):
         self.tags = tags or []
         self.latest_run: Run | None = None
         self.run_has_token_event_map: dict[str, bool] = {}
+        self.tracing_metadata: dict[str, str] | None = (
+            dict(metadata) if metadata is not None else None
+        )
+
+    def copy_with_metadata_defaults(
+        self,
+        *,
+        metadata: Mapping[str, str] | None = None,
+        tags: list[str] | None = None,
+    ) -> LangChainTracer:
+        """Return a new tracer with merged tracer-only defaults."""
+        base_metadata = self.tracing_metadata
+        if metadata is None:
+            merged_metadata = dict(base_metadata) if base_metadata is not None else None
+        elif base_metadata is None:
+            merged_metadata = dict(metadata)
+        else:
+            merged_metadata = dict(base_metadata)
+            for key, value in metadata.items():
+                if key not in merged_metadata:
+                    merged_metadata[key] = value
+
+        merged_tags = sorted(set(self.tags + tags)) if tags else self.tags
+
+        return self.__class__(
+            example_id=self.example_id,
+            project_name=self.project_name,
+            client=self.client,
+            tags=merged_tags,
+            metadata=merged_metadata,
+            run_map=self.run_map,
+            order_map=self.order_map,
+        )
 
     def _start_trace(self, run: Run) -> None:
         if self.project_name:
@@ -263,6 +303,7 @@ class LangChainTracer(BaseTracer):
         try:
             run.extra["runtime"] = get_runtime_environment()
             run.tags = self._get_tags(run)
+            _patch_missing_metadata(self, run)
             if run.ls_client is not self.client:
                 run.ls_client = self.client
             run.post()
@@ -398,3 +439,17 @@ class LangChainTracer(BaseTracer):
         """Wait for the given futures to complete."""
         if self.client is not None:
             self.client.flush()
+
+
+def _patch_missing_metadata(self: LangChainTracer, run: Run) -> None:
+    if not self.tracing_metadata:
+        return
+    metadata = run.metadata
+    patched = None
+    for k, v in self.tracing_metadata.items():
+        if k not in metadata:
+            if patched is None:
+                # Copy on first miss to avoid mutating the shared dict.
+                patched = {**metadata}
+                run.extra["metadata"] = patched
+            patched[k] = v