feat!: prepare v5 release

.github/workflows/ci.yml

@@ -70,17 +70,23 @@ jobs:
       fail-fast: false
       matrix:
         python-version:
-          - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
           - "3.14"
+          - "3.15"
 
     name: Unit tests on Python ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
+      # The pinned uv only knows Python 3.15 pre-releases; install the final release for uv to pick up.
+      - name: Set up Python 3.15
+        if: ${{ matrix.python-version == '3.15' }}
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.15"
       - name: Install uv and set Python version
         uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
         with:
@@ -99,6 +105,14 @@ jobs:
           python --version
           uv run --frozen pytest -n auto --dist worksteal -s -v --log-cli-level=INFO tests/unit
 
+      # pydantic < 2.8 matches undiscriminated unions left to right, so the
+      # CreateScoresResponse member order matters there.
+      - name: Run score response parsing on pydantic 2.7
+        if: ${{ matrix.python-version == '3.11' }}
+        run: |
+          uv run --frozen --with "pydantic==2.7.4" python -c "import pydantic; assert pydantic.VERSION == '2.7.4', pydantic.VERSION"
+          uv run --frozen --with "pydantic==2.7.4" pytest -v tests/unit/test_scores_batch_response.py
+
   e2e-tests:
     runs-on: ubuntu-latest
     timeout-minutes: 30
@@ -160,8 +174,6 @@ jobs:
           LANGFUSE_SERVER_SHA="$(git ls-remote https://github.com/langfuse/langfuse.git HEAD | cut -f1)"
           curl -fsSL "https://raw.githubusercontent.com/langfuse/langfuse/${LANGFUSE_SERVER_SHA}/docker-compose.yml" \
             -o ./langfuse-server/docker-compose.yml
-          cp ./.github/langfuse-v4-dual-write.override.yml \
-            ./langfuse-server/docker-compose.override.yml
           echo "${LANGFUSE_SERVER_SHA}"
 
       - name: Run langfuse server

AGENTS.md

@@ -109,7 +109,7 @@ Minimum verification matrix:
 The main CI workflow currently runs:
 - linting on Python 3.13
 - mypy on Python 3.13
-- `tests/unit` on a Python 3.10-3.14 matrix
+- `tests/unit` on a Python 3.11-3.15 matrix
 - `tests/e2e` in 2 mechanical shards plus a serial subset inside each shard
 - `tests/live_provider` as one always-on suite
 - PR title validation for Conventional Commits

langfuse/_client/attributes.py

@@ -20,6 +20,7 @@
 )
 from langfuse._utils.serializer import EventSerializer
 from langfuse.api import MapValue
+from langfuse.logger import langfuse_logger
 from langfuse.model import PromptClient
 from langfuse.types import SpanLevel
 
@@ -32,8 +33,6 @@ class LangfuseOtelSpanAttributes:
     TRACE_TAGS = "langfuse.trace.tags"
     TRACE_PUBLIC = "langfuse.trace.public"
     TRACE_METADATA = "langfuse.trace.metadata"
-    TRACE_INPUT = "langfuse.trace.input"
-    TRACE_OUTPUT = "langfuse.trace.output"
 
     # Langfuse-observation attributes
     OBSERVATION_TYPE = "langfuse.observation.type"
@@ -68,20 +67,17 @@ class LangfuseOtelSpanAttributes:
     EXPERIMENT_METADATA = "langfuse.experiment.metadata"
     EXPERIMENT_DATASET_ID = "langfuse.experiment.dataset.id"
     EXPERIMENT_ITEM_ID = "langfuse.experiment.item.id"
+    EXPERIMENT_ITEM_VERSION = "langfuse.experiment.item.version"
     EXPERIMENT_ITEM_EXPECTED_OUTPUT = "langfuse.experiment.item.expected_output"
     EXPERIMENT_ITEM_METADATA = "langfuse.experiment.item.metadata"
     EXPERIMENT_ITEM_ROOT_OBSERVATION_ID = "langfuse.experiment.item.root_observation_id"
 
 
 def create_trace_attributes(
     *,
-    input: Optional[Any] = None,
-    output: Optional[Any] = None,
     public: Optional[bool] = None,
 ) -> dict:
     attributes = {
-        LangfuseOtelSpanAttributes.TRACE_INPUT: _serialize(input),
-        LangfuseOtelSpanAttributes.TRACE_OUTPUT: _serialize(output),
         LangfuseOtelSpanAttributes.TRACE_PUBLIC: public,
     }
 
@@ -165,30 +161,24 @@ def _serialize(obj: Any) -> Optional[str]:
     return json.dumps(obj, cls=EventSerializer)
 
 
-def _flatten_and_serialize_metadata_values(
-    metadata: Optional[Dict[str, Any]],
-) -> Optional[Dict[str, str]]:
-    if metadata is None:
-        return None
-
-    flattened_metadata: Dict[str, str] = {}
-
-    def flatten_value(path: str, value: Any) -> None:
-        if isinstance(value, dict):
-            for nested_key, nested_value in value.items():
-                flatten_value(f"{path}.{nested_key}", nested_value)
+def _serialize_metadata_value(value: Any) -> str:
+    """JSON-encode one metadata value, strings included.
 
-            return
+    The server decodes metadata values from v5 SDKs, so encoding every value
+    keeps "123" and 123 distinct. EventSerializer turns ints outside the
+    JS-safe range and NaN/Infinity into JSON strings and never raises, so one
+    bad value cannot drop the other keys. Compact separators and raw non-ASCII
+    match JS JSON.stringify.
+    """
+    # Plain strings skip EventSerializer, which returns them unchanged and then
+    # uses the same string encoder, so the output is identical but cheaper.
+    # str subclasses (e.g. str enums) still go through EventSerializer.
+    if type(value) is str:
+        return json.dumps(value, ensure_ascii=False)
 
-        serialized_value = _serialize(value)
-
-        if serialized_value is not None:
-            flattened_metadata[path] = serialized_value
-
-    for key, value in metadata.items():
-        flatten_value(str(key), value)
-
-    return flattened_metadata
+    return json.dumps(
+        value, cls=EventSerializer, separators=(",", ":"), ensure_ascii=False
+    )
 
 
 def _flatten_and_serialize_metadata(
@@ -200,16 +190,24 @@ def _flatten_and_serialize_metadata(
         else LangfuseOtelSpanAttributes.TRACE_METADATA
     )
 
-    metadata_attributes: Dict[str, Union[str, int, None]] = {}
+    metadata_attributes: Dict[str, Optional[str]] = {}
 
     if not isinstance(metadata, dict):
-        metadata_attributes[prefix] = _serialize(metadata)
+        # JSON-encode non-dict metadata too, strings included, matching the
+        # per-key values below. None stays None so it is not written.
+        metadata_attributes[prefix] = (
+            None if metadata is None else _serialize_metadata_value(metadata)
+        )
     else:
         for key, value in metadata.items():
-            metadata_attributes[f"{prefix}.{key}"] = (
-                value
-                if isinstance(value, str) or isinstance(value, int)
-                else _serialize(value)
-            )
+            # Skip None so an update does not overwrite an earlier value.
+            if value is None:
+                langfuse_logger.debug(
+                    'Observation metadata key "%s" was not written because its value is None',
+                    key,
+                )
+                continue
+
+            metadata_attributes[f"{prefix}.{key}"] = _serialize_metadata_value(value)
 
     return metadata_attributes