arize-phoenix 0.0.32rc1__tar.gz → 0.0.33__tar.gz

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/.gitignore

@@ -21,3 +21,6 @@ sdist
 
 # Testing
 coverage.xml
+
+# Un-supported files
+pnpm-lock.yaml

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arize-phoenix
-Version: 0.0.32rc1
+Version: 0.0.33
 Summary: ML Observability in your notebook
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -19,13 +19,14 @@ Requires-Python: <3.12,>=3.8
 Requires-Dist: hdbscan<1.0.0,>=0.8.33
 Requires-Dist: numpy
 Requires-Dist: pandas
-Requires-Dist: portpicker
+Requires-Dist: protobuf<5.0,>=3.20
 Requires-Dist: psutil
 Requires-Dist: pyarrow
 Requires-Dist: scikit-learn<1.3.0
 Requires-Dist: scipy
+Requires-Dist: sortedcontainers
 Requires-Dist: starlette
-Requires-Dist: strawberry-graphql==0.178.0
+Requires-Dist: strawberry-graphql==0.205.0
 Requires-Dist: typing-extensions
 Requires-Dist: umap-learn
 Requires-Dist: uvicorn
@@ -33,15 +34,20 @@ Requires-Dist: wrapt
 Provides-Extra: dev
 Requires-Dist: arize[autoembeddings,llm-evaluation]; extra == 'dev'
 Requires-Dist: black[jupyter]; extra == 'dev'
+Requires-Dist: gcsfs; extra == 'dev'
 Requires-Dist: hatch; extra == 'dev'
 Requires-Dist: jupyter; extra == 'dev'
-Requires-Dist: pandas-stubs; extra == 'dev'
+Requires-Dist: nbqa; extra == 'dev'
+Requires-Dist: pandas-stubs<=2.0.2.230605; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-lazy-fixture; extra == 'dev'
-Requires-Dist: strawberry-graphql[debug-server]==0.178.0; extra == 'dev'
+Requires-Dist: ruff==0.0.289; extra == 'dev'
+Requires-Dist: strawberry-graphql[debug-server]==0.205.0; extra == 'dev'
 Provides-Extra: experimental
+Requires-Dist: langchain>=0.0.257; extra == 'experimental'
+Requires-Dist: llama-index>=0.8.25; extra == 'experimental'
 Requires-Dist: openai; extra == 'experimental'
 Requires-Dist: tenacity; extra == 'experimental'
 Description-Content-Type: text/markdown

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/pyproject.toml

@@ -29,29 +29,35 @@ dependencies = [
   "starlette",
   "uvicorn",
   "psutil",
-  "strawberry-graphql==0.178.0",
+  "strawberry-graphql==0.205.0",
   "pyarrow",
   "typing_extensions",
   "scipy",
-  "portpicker",
   "wrapt",
+  "sortedcontainers",
+  "protobuf>=3.20, <5.0",
 ]
 dynamic = ["version"]
 
 [project.optional-dependencies]
 dev = [
   "black[jupyter]",
+  "gcsfs",
   "hatch",
   "jupyter",
-  "pandas-stubs",
+  "nbqa",
+  "ruff==0.0.289",
+  "pandas-stubs<=2.0.2.230605",  # version 2.0.3.230814 is causing a dependency conflict.
   "pytest",
   "pytest-cov",
   "pytest-lazy-fixture",
-  "strawberry-graphql[debug-server]==0.178.0",
+  "strawberry-graphql[debug-server]==0.205.0",
   "pre-commit",
   "arize[AutoEmbeddings, LLM_Evaluation]",
 ]
 experimental = [
+  "langchain>=0.0.257",
+  "llama-index>=0.8.25",
   "openai",
   "tenacity",
 ]
@@ -90,29 +96,40 @@ artifacts = ["src/phoenix/server/static"]
 
 [tool.hatch.envs.default]
 dependencies = [
+  "pandas==1.4.0",
   "pytest",
   "pytest-cov",
   "pytest-lazy-fixture",
   "arize",
+  "langchain>=0.0.257",
+  "llama-index>=0.8.25",
   "openai",
   "tenacity",
+  "nltk==3.8.1",
+  "sentence-transformers==2.2.2",
+  "pydantic<2",  # for @root_validator in llama-index
+  "requests",
+  "protobuf==3.20",  # version minimum (for tests)
+  "responses",
 ]
 
 [tool.hatch.envs.type]
 dependencies = [
-  "mypy==1.3.0",
-  "pandas-stubs",
-  "pytest",
+  "mypy==1.5.1",
+  "llama-index>=0.8.25",
+  "pandas-stubs<=2.0.2.230605",  # version 2.0.3.230814 is causing a dependency conflict.
   "types-psutil",
-  "tenacity",
+  "types-tqdm",
+  "types-requests",
+  "types-protobuf",
 ]
 
 [tool.hatch.envs.style]
 detached = true
 dependencies = [
-  "black~=23.1.0",
-  "black[jupyter]~=23.1.0",
-  "ruff~=0.0.254",
+  "black~=23.3.0",
+  "black[jupyter]~=23.3.0",
+  "ruff~=0.0.289",
 ]
 
 [tool.hatch.envs.notebooks]
@@ -199,6 +216,7 @@ pypi = [
 
 [tool.black]
 line-length = 100
+exclude = '_pb2\.pyi?$'
 
 [tool.hatch.envs.docs.scripts]
 check = [
@@ -206,10 +224,23 @@ check = [
 ]
 
 [tool.hatch.envs.gql]
+dependencies = [
+  "strawberry-graphql[cli]==0.205.0",
+]
 
 [tool.hatch.envs.gql.scripts]
 build = 'strawberry export-schema phoenix.server.api.schema:schema > app/schema.graphql'
 
+[tool.hatch.envs.proto]
+detached = true
+dependencies = [
+  "grpcio-tools==1.54.3",
+  "mypy-protobuf==3.5.0",
+]
+
+[tool.hatch.envs.proto.scripts]
+recompile = "python -m grpc_tools.protoc -I src/phoenix/proto --python_out=src/phoenix --mypy_out=src/phoenix src/phoenix/proto/trace/v1/trace.proto"
+
 [tool.interrogate]
 fail-under = 0
 # generate-badge = "badges/"
@@ -226,13 +257,14 @@ ignore-nested-classes = false
 ignore-setters = false
 
 [tool.mypy]
-plugins = ["strawberry.ext.mypy_plugin"]
+plugins = ["strawberry.ext.mypy_plugin", "pydantic.mypy"]
 disallow_untyped_calls = true
 disallow_untyped_defs = true
 disallow_incomplete_defs  = true
 strict = true
 exclude = [
   "dist/",
+  "scripts/data/",
   "sdist/",
   "tests/",
   "tutorials/",
@@ -246,14 +278,14 @@ module = [
   "scipy.*",
   "sklearn.*",
   "arize.*",
-  "portpicker",
   "wrapt",
-  "openai",
+  "sortedcontainers",
+  "langchain.*",
 ]
 ignore_missing_imports = true
 
 [tool.ruff]
-exclude = [".git", "__pycache__", "docs/source/conf.py"]
+exclude = [".git", "__pycache__", "docs/source/conf.py", "*_pb2.py*"]
 ignore-init-module-imports = true
 line-length = 100
 select = ["E", "F", "W", "I"]

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/src/phoenix/__init__.py

@@ -3,8 +3,9 @@ from .datasets.fixtures import ExampleDatasets, load_example
 from .datasets.schema import EmbeddingColumnNames, RetrievalEmbeddingColumnNames, Schema
 from .session.session import Session, active_session, close_app, launch_app
 from .trace.fixtures import load_example_traces
+from .trace.trace_dataset import TraceDataset
 
-__version__ = "0.0.32rc1"
+__version__ = "0.0.33"
 
 # module level doc-string
 __doc__ = """
@@ -34,4 +35,5 @@ __all__ = [
     "launch_app",
     "Session",
     "load_example_traces",
+    "TraceDataset",
 ]

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/src/phoenix/config.py

@@ -1,6 +1,7 @@
+import os
 import tempfile
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
 
 def _get_temp_path() -> Path:
@@ -18,6 +19,13 @@ def get_pids_path() -> Path:
     return path
 
 
+def get_running_pid() -> Optional[int]:
+    for file in get_pids_path().iterdir():
+        if file.name.isnumeric():
+            return int(file.name)
+    return None
+
+
 for path in (
     ROOT_DIR := Path.home().resolve() / ".phoenix",
     EXPORT_DIR := ROOT_DIR / "exports",
@@ -28,6 +36,8 @@ for path in (
 PHOENIX_DIR = Path(__file__).resolve().parent
 # Server config
 SERVER_DIR = PHOENIX_DIR / "server"
+# The host the server will run on after launch_app is called
+HOST = "127.0.0.1"
 # The port the server will run on after launch_app is called
 PORT = 6060
 # The prefix of datasets that are auto-assigned a name
@@ -49,3 +59,15 @@ def get_exported_files(directory: Path) -> List[Path]:
         List of paths of the exported files.
     """
     return list(directory.glob("*.parquet"))
+
+
+def get_env_port() -> int:
+    return (
+        int(port)
+        if isinstance(port := os.getenv("PHOENIX_PORT"), str) and port.isnumeric()
+        else PORT
+    )
+
+
+def get_env_host() -> str:
+    return os.getenv("PHOENIX_HOST") or HOST

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/src/phoenix/core/model_schema.py

@@ -49,6 +49,7 @@ from typing_extensions import TypeAlias, TypeGuard
 from wrapt import ObjectProxy
 
 from phoenix.config import GENERATED_DATASET_NAME_PREFIX
+from phoenix.datetime_utils import floor_to_minute
 
 
 class DimensionRole(IntEnum):
@@ -328,10 +329,7 @@ class Column:
             except KeyError:
                 # It's important to glue the index to the default series,
                 # so it would look like the series came from the dataframe.
-                return self._default(len(data)).set_axis(
-                    data.index,
-                    copy=False,
-                )
+                return self._default(len(data)).set_axis(data.index)
         if isinstance(data, pd.Series):
             try:
                 return data.at[self.name]
@@ -657,8 +655,8 @@ class Events(ModelData):
         # open and one minute is the smallest interval allowed.
         stop_time = end_time + timedelta(minutes=1)
         # Round down to the nearest minute.
-        start = _floor_to_minute(start_time)
-        stop = _floor_to_minute(stop_time)
+        start = floor_to_minute(start_time)
+        stop = floor_to_minute(stop_time)
         return TimeRange(start, stop)
 
     def __iter__(self) -> Iterator[Event]:
@@ -721,6 +719,10 @@ class Dataset(Events):
     def role(self) -> DatasetRole:
         return self._self_role
 
+    @property
+    def is_empty(self) -> bool:
+        return len(self) == 0
+
     @cached_property
     def primary_key(self) -> pd.Index:
         return pd.Index(self[PREDICTION_ID])
@@ -736,10 +738,7 @@ class Dataset(Events):
     def __getitem__(self, key: Any) -> Any:
         if isinstance(key, list):
             return Events(
-                self.iloc[key].set_axis(
-                    key,
-                    copy=False,
-                ),
+                self.iloc[key].set_axis(key),
                 role=self._self_role,
                 _model=self._self_model,
             )
@@ -913,6 +912,11 @@ class Model:
                 df, name=dataset.name, role=dataset_role
             )
 
+    @cached_property
+    def is_empty(self) -> bool:
+        """Returns True if the model has no data."""
+        return not any(map(len, self._datasets.values()))
+
     def export_rows_as_parquet_file(
         self,
         row_numbers: Mapping[DatasetRole, Iterable[int]],
@@ -1390,7 +1394,6 @@ def _coerce_str_column_names(
         df.set_axis(
             df.columns.astype(str),
             axis=1,
-            copy=False,
         )
         for df in dataframes
     )
@@ -1432,32 +1435,6 @@ def _title_case_no_underscore(name: str) -> str:
     return _id_pat.sub("ID", name.replace("_", " ").title())
 
 
-MINUTE_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:00%z"
-
-
-def _floor_to_minute(dt: datetime) -> datetime:
-    """Floor datetime to the minute by taking a round-trip through string
-    format because there isn't always an available function to strip the
-    nanoseconds if present."""
-    try:
-        dt_as_string = dt.astimezone(
-            timezone.utc,
-        ).strftime(
-            MINUTE_DATETIME_FORMAT,
-        )
-    except ValueError:
-        # NOTE: as of Python 3.8.16, pandas 1.5.3:
-        # >>> isinstance(pd.NaT, datetime.datetime)
-        # True
-        return cast(datetime, pd.NaT)
-    return datetime.strptime(
-        dt_as_string,
-        MINUTE_DATETIME_FORMAT,
-    ).astimezone(
-        timezone.utc,
-    )
-
-
 def _jsonify(obj: Any) -> Any:
     if getattr(obj, "__dataclass_fields__", None):
         return {

{arize_phoenix-0.0.32rc1 → arize_phoenix-0.0.33}/src/phoenix/core/model_schema_adapter.py

@@ -43,7 +43,6 @@ def create_model_from_datasets(*datasets: Optional[Dataset]) -> Model:
         df = df.set_axis(
             map(str, df.columns),
             axis=1,
-            copy=False,
         )
         named_dataframes.append((dataset.name, df))
         dataset_schema = dataset.schema if dataset.schema is not None else DatasetSchema()

arize_phoenix-0.0.33/src/phoenix/core/traces.py

@@ -0,0 +1,285 @@
+import weakref
+from collections import defaultdict
+from datetime import datetime, timezone
+from queue import SimpleQueue
+from threading import RLock, Thread
+from types import MethodType
+from typing import (
+    Any,
+    DefaultDict,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    SupportsFloat,
+    Tuple,
+    Union,
+    cast,
+)
+from uuid import UUID
+
+from sortedcontainers import SortedKeyList
+from typing_extensions import TypeAlias
+from wrapt import ObjectProxy
+
+import phoenix.trace.v1.trace_pb2 as pb
+from phoenix.datetime_utils import right_open_time_range
+from phoenix.trace import semantic_conventions
+from phoenix.trace.schemas import (
+    ATTRIBUTE_PREFIX,
+    COMPUTED_PREFIX,
+    CONTEXT_PREFIX,
+    Span,
+    SpanAttributes,
+    SpanID,
+    TraceID,
+)
+from phoenix.trace.v1 import decode, encode
+
+NAME = "name"
+STATUS_CODE = "status_code"
+SPAN_KIND = "span_kind"
+TRACE_ID = CONTEXT_PREFIX + "trace_id"
+SPAN_ID = CONTEXT_PREFIX + "span_id"
+PARENT_ID = "parent_id"
+START_TIME = "start_time"
+END_TIME = "end_time"
+LLM_TOKEN_COUNT_TOTAL = ATTRIBUTE_PREFIX + semantic_conventions.LLM_TOKEN_COUNT_TOTAL
+LLM_TOKEN_COUNT_PROMPT = ATTRIBUTE_PREFIX + semantic_conventions.LLM_TOKEN_COUNT_PROMPT
+LLM_TOKEN_COUNT_COMPLETION = ATTRIBUTE_PREFIX + semantic_conventions.LLM_TOKEN_COUNT_COMPLETION
+LATENCY_MS = COMPUTED_PREFIX + "latency_ms"  # The latency (or duration) of the span in milliseconds
+CUMULATIVE_LLM_TOKEN_COUNT_TOTAL = COMPUTED_PREFIX + "cumulative_token_count_total"
+CUMULATIVE_LLM_TOKEN_COUNT_PROMPT = COMPUTED_PREFIX + "cumulative_token_count_prompt"
+CUMULATIVE_LLM_TOKEN_COUNT_COMPLETION = COMPUTED_PREFIX + "cumulative_token_count_completion"
+
+
+class ReadableSpan(ObjectProxy):  # type: ignore
+    """
+    A wrapped a protobuf Span, with access methods and ability to decode to
+    a python span. It's meant to be interface layer separating use from
+    implementation. It can also provide computed values that are not intrinsic
+    to the span, e.g. the latency rank percent which can change as more spans
+    are ingested, and would need to be re-computed on the fly.
+    """
+
+    __wrapped__: pb.Span
+
+    def __init__(self, span: pb.Span) -> None:
+        super().__init__(span)
+        self._self_computed_values: Dict[str, SupportsFloat] = {}
+
+    @property
+    def span(self) -> Span:
+        span = decode(self.__wrapped__)
+        span.attributes.update(cast(SpanAttributes, self._self_computed_values))
+        # TODO: compute latency rank percent (which can change depending on how
+        # many spans already ingested).
+        return span
+
+    def __getitem__(self, key: str) -> Any:
+        if key.startswith(COMPUTED_PREFIX):
+            return self._self_computed_values.get(key)
+        if key.startswith(CONTEXT_PREFIX):
+            suffix_key = key[len(CONTEXT_PREFIX) :]
+            return getattr(self.__wrapped__.context, suffix_key, None)
+        if key.startswith(ATTRIBUTE_PREFIX):
+            suffix_key = key[len(ATTRIBUTE_PREFIX) :]
+            if suffix_key not in self.__wrapped__.attributes:
+                return None
+            return self.__wrapped__.attributes[suffix_key]
+        return getattr(self.__wrapped__, key, None)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        if not key.startswith(COMPUTED_PREFIX):
+            raise KeyError(f"{key} is not a computed value")
+        self._self_computed_values[key] = value
+
+
+ParentSpanID: TypeAlias = SpanID
+ChildSpanID: TypeAlias = SpanID
+
+
+class Traces:
+    def __init__(self, spans: Optional[Iterable[Span]] = None) -> None:
+        self._queue: "SimpleQueue[Optional[pb.Span]]" = SimpleQueue()
+        # Putting `None` as the sentinel value for queue termination.
+        weakref.finalize(self, self._queue.put, None)
+        for span in spans or ():
+            self.put(span)
+        self._lock = RLock()
+        self._spans: Dict[SpanID, ReadableSpan] = {}
+        self._parent_span_ids: Dict[SpanID, ParentSpanID] = {}
+        self._traces: Dict[TraceID, List[SpanID]] = defaultdict(list)
+        self._child_span_ids: DefaultDict[SpanID, List[ChildSpanID]] = defaultdict(list)
+        self._orphan_spans: DefaultDict[ParentSpanID, List[pb.Span]] = defaultdict(list)
+        self._start_time_sorted_span_ids: SortedKeyList[SpanID] = SortedKeyList(
+            key=lambda span_id: self._spans[span_id].start_time.ToDatetime(timezone.utc),
+        )
+        self._start_time_sorted_root_span_ids: SortedKeyList[SpanID] = SortedKeyList(
+            key=lambda span_id: self._spans[span_id].start_time.ToDatetime(timezone.utc),
+        )
+        self._latency_sorted_root_span_ids: SortedKeyList[SpanID] = SortedKeyList(
+            key=lambda span_id: self._spans[span_id][LATENCY_MS],
+        )
+        self._min_start_time: Optional[datetime] = None
+        self._max_start_time: Optional[datetime] = None
+        self._start_consumer()
+
+    def put(self, span: Optional[Union[Span, pb.Span]] = None) -> None:
+        self._queue.put(encode(span) if isinstance(span, Span) else span)
+
+    def get_trace(self, trace_id: TraceID) -> Iterator[Span]:
+        for span_id in self._traces[trace_id]:
+            if span := self[span_id]:
+                yield span
+
+    def get_spans(
+        self,
+        start_time: Optional[datetime] = None,
+        stop_time: Optional[datetime] = None,
+        root_spans_only: Optional[bool] = False,
+    ) -> Iterator[Span]:
+        if not self._spans:
+            return
+        min_start_time, max_stop_time = cast(
+            Tuple[datetime, datetime],
+            self.right_open_time_range,
+        )
+        start_time = start_time or min_start_time
+        stop_time = stop_time or max_stop_time
+        sorted_span_ids = (
+            self._start_time_sorted_root_span_ids
+            if root_spans_only
+            else self._start_time_sorted_span_ids
+        )
+        for span_id in sorted_span_ids.irange_key(
+            start_time.astimezone(timezone.utc),
+            stop_time.astimezone(timezone.utc),
+            inclusive=(True, False),
+            reverse=True,  # most recent spans first
+        ):
+            if span := self[span_id]:
+                yield span
+
+    def latency_rank_percent(self, latency_ms: float) -> Optional[float]:
+        """
+        Returns a value between 0 and 100 approximating the rank of the
+        latency value as percent of the total count of root spans. E.g., for
+        a latency value at the 75th percentile, the result is roughly 75.
+        """
+        root_span_ids = self._latency_sorted_root_span_ids
+        if not (n := len(root_span_ids)):
+            return None
+        rank = cast(int, root_span_ids.bisect_key_left(latency_ms))
+        return rank / n * 100
+
+    def get_descendant_span_ids(self, span_id: SpanID) -> Iterator[SpanID]:
+        for child_span_id in self._child_span_ids.get(span_id) or ():
+            yield child_span_id
+            yield from self.get_descendant_span_ids(child_span_id)
+
+    @property
+    def span_count(self) -> int:
+        """Total number of spans (excluding orphan spans if any)"""
+        return len(self._spans)
+
+    @property
+    def right_open_time_range(self) -> Tuple[Optional[datetime], Optional[datetime]]:
+        return right_open_time_range(self._min_start_time, self._max_start_time)
+
+    def __getitem__(self, span_id: SpanID) -> Optional[Span]:
+        with self._lock:
+            if span := self._spans.get(span_id):
+                return span.span
+        return None
+
+    def _start_consumer(self) -> None:
+        Thread(
+            target=MethodType(
+                self.__class__._consume_spans,
+                weakref.proxy(self),
+            ),
+            daemon=True,
+        ).start()
+
+    def _consume_spans(self) -> None:
+        while True:
+            if not (span := self._queue.get()):
+                return
+            with self._lock:
+                self._process_span(span)
+
+    def _process_span(self, span: pb.Span) -> None:
+        span_id = UUID(bytes=span.context.span_id)
+        existing_span = self._spans.get(span_id)
+        if existing_span and existing_span.end_time:
+            # Reject updates if span has ended.
+            return
+        is_root_span = not span.HasField("parent_span_id")
+        if not is_root_span:
+            parent_span_id = UUID(bytes=span.parent_span_id.value)
+            if parent_span_id not in self._spans:
+                # Span can't be processed before its parent.
+                self._orphan_spans[parent_span_id].append(span)
+                return
+            self._child_span_ids[parent_span_id].append(span_id)
+            self._parent_span_ids[span_id] = parent_span_id
+        new_span = ReadableSpan(span)
+        start_time = span.start_time.ToDatetime(timezone.utc)
+        end_time = span.end_time.ToDatetime(timezone.utc) if span.HasField("end_time") else None
+        if end_time:
+            new_span[LATENCY_MS] = (end_time - start_time).total_seconds() * 1000
+        self._spans[span_id] = new_span
+        if is_root_span and end_time:
+            self._latency_sorted_root_span_ids.add(span_id)
+        if not existing_span:
+            trace_id = UUID(bytes=span.context.trace_id)
+            self._traces[trace_id].append(span_id)
+            if is_root_span:
+                self._start_time_sorted_root_span_ids.add(span_id)
+            self._start_time_sorted_span_ids.add(span_id)
+            self._min_start_time = (
+                start_time
+                if self._min_start_time is None
+                else min(self._min_start_time, start_time)
+            )
+            self._max_start_time = (
+                start_time
+                if self._max_start_time is None
+                else max(self._max_start_time, start_time)
+            )
+        # Update cumulative values for span's ancestors.
+        for attribute_name, cumulative_attribute_name in (
+            (LLM_TOKEN_COUNT_TOTAL, CUMULATIVE_LLM_TOKEN_COUNT_TOTAL),
+            (LLM_TOKEN_COUNT_PROMPT, CUMULATIVE_LLM_TOKEN_COUNT_PROMPT),
+            (LLM_TOKEN_COUNT_COMPLETION, CUMULATIVE_LLM_TOKEN_COUNT_COMPLETION),
+        ):
+            existing_value = (existing_span[attribute_name] or 0) if existing_span else 0
+            new_value = new_span[attribute_name] or 0
+            if not (difference := new_value - existing_value):
+                continue
+            existing_cumulative_value = (
+                (existing_span[cumulative_attribute_name] or 0) if existing_span else 0
+            )
+            new_span[cumulative_attribute_name] = difference + existing_cumulative_value
+            self._add_value_to_span_ancestors(
+                span_id,
+                cumulative_attribute_name,
+                difference,
+            )
+        # Process previously orphaned spans, if any.
+        for orphan_span in self._orphan_spans[span_id]:
+            self._process_span(orphan_span)
+
+    def _add_value_to_span_ancestors(
+        self,
+        span_id: SpanID,
+        attribute_name: str,
+        value: float,
+    ) -> None:
+        while parent_span_id := self._parent_span_ids.get(span_id):
+            parent_span = self._spans[parent_span_id]
+            cumulative_value = parent_span[attribute_name] or 0
+            parent_span[attribute_name] = cumulative_value + value
+            span_id = parent_span_id