arize-phoenix 11.32.1__py3-none-any.whl → 11.34.0__py3-none-any.whl

phoenix/server/app.py

@@ -4,7 +4,6 @@ import importlib
 import json
 import logging
 import os
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
 from contextlib import AbstractAsyncContextManager, AsyncExitStack
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
@@ -14,9 +13,14 @@ from types import MethodType
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Iterable,
     NamedTuple,
     Optional,
     Protocol,
+    Sequence,
     TypedDict,
     Union,
     cast,
@@ -64,6 +68,7 @@ from phoenix.config import (
     get_env_grpc_interceptor_paths,
     get_env_host,
     get_env_host_root_path,
+    get_env_max_spans_queue_size,
     get_env_port,
     get_env_support_email,
     server_instrumentation_is_enabled,
@@ -81,15 +86,20 @@ from phoenix.server.api.context import Context, DataLoaders
 from phoenix.server.api.dataloaders import (
     AnnotationConfigsByProjectDataLoader,
     AnnotationSummaryDataLoader,
+    AverageExperimentRepeatedRunGroupLatencyDataLoader,
     AverageExperimentRunLatencyDataLoader,
     CacheForDataLoaders,
     DatasetExampleRevisionsDataLoader,
+    DatasetExamplesAndVersionsByExperimentRunDataLoader,
     DatasetExampleSpansDataLoader,
     DocumentEvaluationsDataLoader,
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
     ExperimentAnnotationSummaryDataLoader,
     ExperimentErrorRatesDataLoader,
+    ExperimentRepeatedRunGroupAnnotationSummariesDataLoader,
+    ExperimentRepeatedRunGroupsDataLoader,
+    ExperimentRepetitionCountsDataLoader,
     ExperimentRunAnnotations,
     ExperimentRunCountsDataLoader,
     ExperimentSequenceNumberDataLoader,
@@ -116,6 +126,7 @@ from phoenix.server.api.dataloaders import (
     SpanCostDetailSummaryEntriesBySpanDataLoader,
     SpanCostDetailSummaryEntriesByTraceDataLoader,
     SpanCostSummaryByExperimentDataLoader,
+    SpanCostSummaryByExperimentRepeatedRunGroupDataLoader,
     SpanCostSummaryByExperimentRunDataLoader,
     SpanCostSummaryByGenerativeModelDataLoader,
     SpanCostSummaryByProjectDataLoader,
@@ -151,6 +162,7 @@ from phoenix.server.grpc_server import GrpcServer
 from phoenix.server.jwt_store import JwtStore
 from phoenix.server.middleware.gzip import GZipMiddleware
 from phoenix.server.oauth2 import OAuth2Clients
+from phoenix.server.prometheus import SPAN_QUEUE_REJECTIONS
 from phoenix.server.retention import TraceDataSweeper
 from phoenix.server.telemetry import initialize_opentelemetry_tracer_provider
 from phoenix.server.types import (
@@ -427,13 +439,13 @@ class Scaffolder(DaemonTask):
     def __init__(
         self,
         config: ScaffolderConfig,
-        queue_span: Callable[[Span, ProjectName], Awaitable[None]],
-        queue_evaluation: Callable[[pb.Evaluation], Awaitable[None]],
+        enqueue_span: Callable[[Span, ProjectName], Awaitable[None]],
+        enqueue_evaluation: Callable[[pb.Evaluation], Awaitable[None]],
     ) -> None:
         super().__init__()
         self._db = config.db
-        self._queue_span = queue_span
-        self._queue_evaluation = queue_evaluation
+        self._enqueue_span = enqueue_span
+        self._enqueue_evaluation = enqueue_evaluation
         self._tracing_fixtures = [
             get_trace_fixture_by_name(name) for name in set(config.tracing_fixture_names)
         ]
@@ -504,9 +516,9 @@ class Scaffolder(DaemonTask):
                 project_name = fixture.project_name or fixture.name
                 logger.info(f"Loading '{project_name}' fixtures...")
                 for span in fixture_spans:
-                    await self._queue_span(span, project_name)
+                    await self._enqueue_span(span, project_name)
                 for evaluation in fixture_evals:
-                    await self._queue_evaluation(evaluation)
+                    await self._enqueue_evaluation(evaluation)
 
             except FileNotFoundError:
                 logger.warning(f"Fixture file not found for '{fixture.name}'")
@@ -529,6 +541,32 @@ class Scaffolder(DaemonTask):
             logger.error(f"Error processing dataset fixture: {e}")
 
 
+class _CapacityIndicator(Protocol):
+    @property
+    def is_full(self) -> bool: ...
+
+
+class CapacityInterceptor(AsyncServerInterceptor):
+    def __init__(self, indicator: _CapacityIndicator):
+        self._indicator = indicator
+
+    @override
+    async def intercept(
+        self,
+        method: Callable[[Any, grpc.aio.ServicerContext], Awaitable[Any]],
+        request_or_iterator: Any,
+        context: grpc.aio.ServicerContext,
+        method_name: str,
+    ) -> Any:
+        if self._indicator.is_full:
+            SPAN_QUEUE_REJECTIONS.inc()
+            context.set_code(grpc.StatusCode.RESOURCE_EXHAUSTED)
+            context.set_details("Server is at capacity and cannot process more requests")
+            return
+
+        return await method(request_or_iterator, context)
+
+
 def _lifespan(
     *,
     db: DbSessionFactory,
@@ -555,18 +593,23 @@ def _lifespan(
         db.lock = asyncio.Lock() if db.dialect is SupportedSQLDialect.SQLITE else None
         async with AsyncExitStack() as stack:
             (
-                enqueue,
-                queue_span,
-                queue_evaluation,
+                enqueue_annotations,
+                enqueue_span,
+                enqueue_evaluation,
                 enqueue_operation,
             ) = await stack.enter_async_context(bulk_inserter)
+            interceptors = [
+                CapacityInterceptor(bulk_inserter),
+                *user_grpc_interceptors(),
+                *grpc_interceptors,
+            ]
             grpc_server = GrpcServer(
-                queue_span,
+                enqueue_span,
                 disabled=read_only,
                 tracer_provider=tracer_provider,
                 enable_prometheus=enable_prometheus,
                 token_store=token_store,
-                interceptors=user_grpc_interceptors() + list(grpc_interceptors),
+                interceptors=interceptors,
             )
             await stack.enter_async_context(grpc_server)
             await stack.enter_async_context(dml_event_handler)
@@ -578,17 +621,17 @@ def _lifespan(
             if scaffolder_config:
                 scaffolder = Scaffolder(
                     config=scaffolder_config,
-                    queue_span=queue_span,
-                    queue_evaluation=queue_evaluation,
+                    enqueue_span=enqueue_span,
+                    enqueue_evaluation=enqueue_evaluation,
                 )
                 await stack.enter_async_context(scaffolder)
             if isinstance(token_store, AbstractAsyncContextManager):
                 await stack.enter_async_context(token_store)
             yield {
                 "event_queue": dml_event_handler,
-                "enqueue": enqueue,
-                "queue_span_for_bulk_insert": queue_span,
-                "queue_evaluation_for_bulk_insert": queue_evaluation,
+                "enqueue_annotations": enqueue_annotations,
+                "enqueue_span": enqueue_span,
+                "enqueue_evaluation": enqueue_evaluation,
                 "enqueue_operation": enqueue_operation,
             }
         for callback in shutdown_callbacks:
@@ -663,9 +706,15 @@ def create_graphql_router(
             event_queue=event_queue,
             data_loaders=DataLoaders(
                 annotation_configs_by_project=AnnotationConfigsByProjectDataLoader(db),
+                average_experiment_repeated_run_group_latency=AverageExperimentRepeatedRunGroupLatencyDataLoader(
+                    db
+                ),
                 average_experiment_run_latency=AverageExperimentRunLatencyDataLoader(db),
                 dataset_example_revisions=DatasetExampleRevisionsDataLoader(db),
                 dataset_example_spans=DatasetExampleSpansDataLoader(db),
+                dataset_examples_and_versions_by_experiment_run=DatasetExamplesAndVersionsByExperimentRunDataLoader(
+                    db
+                ),
                 document_evaluation_summaries=DocumentEvaluationSummaryDataLoader(
                     db,
                     cache_map=(
@@ -684,6 +733,11 @@ def create_graphql_router(
                 ),
                 experiment_annotation_summaries=ExperimentAnnotationSummaryDataLoader(db),
                 experiment_error_rates=ExperimentErrorRatesDataLoader(db),
+                experiment_repeated_run_group_annotation_summaries=ExperimentRepeatedRunGroupAnnotationSummariesDataLoader(
+                    db
+                ),
+                experiment_repeated_run_groups=ExperimentRepeatedRunGroupsDataLoader(db),
+                experiment_repetition_counts=ExperimentRepetitionCountsDataLoader(db),
                 experiment_run_annotations=ExperimentRunAnnotations(db),
                 experiment_run_counts=ExperimentRunCountsDataLoader(db),
                 experiment_sequence_number=ExperimentSequenceNumberDataLoader(db),
@@ -740,6 +794,11 @@ def create_graphql_router(
                 span_cost_details_by_span_cost=SpanCostDetailsBySpanCostDataLoader(db),
                 span_cost_detail_fields=TableFieldsDataLoader(db, models.SpanCostDetail),
                 span_cost_fields=TableFieldsDataLoader(db, models.SpanCost),
+                span_cost_summary_by_experiment=SpanCostSummaryByExperimentDataLoader(db),
+                span_cost_summary_by_experiment_repeated_run_group=SpanCostSummaryByExperimentRepeatedRunGroupDataLoader(
+                    db
+                ),
+                span_cost_summary_by_experiment_run=SpanCostSummaryByExperimentRunDataLoader(db),
                 span_cost_summary_by_generative_model=SpanCostSummaryByGenerativeModelDataLoader(
                     db
                 ),
@@ -768,8 +827,6 @@ def create_graphql_router(
                 project_by_name=ProjectByNameDataLoader(db),
                 users=UsersDataLoader(db),
                 user_roles=UserRolesDataLoader(db),
-                span_cost_summary_by_experiment=SpanCostSummaryByExperimentDataLoader(db),
-                span_cost_summary_by_experiment_run=SpanCostSummaryByExperimentRunDataLoader(db),
             ),
             cache_for_dataloaders=cache_for_dataloaders,
             read_only=read_only,
@@ -969,11 +1026,11 @@ def create_app(
     span_cost_calculator = SpanCostCalculator(db, generative_model_store)
     bulk_inserter = bulk_inserter_factory(
         db,
-        enable_prometheus=enable_prometheus,
         span_cost_calculator=span_cost_calculator,
         event_queue=dml_event_handler,
         initial_batch_of_spans=initial_batch_of_spans,
         initial_batch_of_evaluations=initial_batch_of_evaluations,
+        max_spans_queue_size=get_env_max_spans_queue_size(),
     )
     tracer_provider = None
     graphql_schema_extensions: list[Union[type[SchemaExtension], SchemaExtension]] = []
@@ -1104,6 +1161,7 @@ def create_app(
     app.state.db = db
     app.state.email_sender = email_sender
     app.state.span_cost_calculator = span_cost_calculator
+    app.state.span_queue_is_full = lambda: bulk_inserter.is_full
     app = _add_get_secret_method(app=app, secret=secret)
     app = _add_get_token_store_method(app=app, token_store=token_store)
     if tracer_provider:

phoenix/server/cost_tracking/model_cost_manifest.json

@@ -698,7 +698,7 @@
           "token_type": "input"
         },
         {
-          "base_rate": 2.5e-6,
+          "base_rate": 0.00003,
           "is_prompt": false,
           "token_type": "output"
         },

phoenix/server/daemons/span_cost_calculator.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 from asyncio import sleep
+from collections import deque
 from datetime import datetime
 from typing import Any, Mapping, NamedTuple, Optional
 
@@ -35,21 +36,25 @@ class SpanCostCalculator(DaemonTask):
         super().__init__()
         self._db = db
         self._model_store = model_store
-        self._queue: list[SpanCostCalculatorQueueItem] = []
+        self._queue: deque[SpanCostCalculatorQueueItem] = deque()
+        self._max_items_per_transaction = 1000
 
     async def _run(self) -> None:
         while self._running:
+            num_items_to_insert = min(self._max_items_per_transaction, len(self._queue))
             try:
-                await self._insert_costs()
+                await self._insert_costs(num_items_to_insert)
             except Exception as e:
                 logger.exception(f"Failed to insert costs: {e}")
             await sleep(self._SLEEP_INTERVAL)
 
-    async def _insert_costs(self) -> None:
-        if not self._queue:
+    async def _insert_costs(self, num_items_to_insert: int) -> None:
+        if not num_items_to_insert or not self._queue:
             return
         costs: list[models.SpanCost] = []
-        for item in self._queue:
+        while num_items_to_insert > 0:
+            num_items_to_insert -= 1
+            item = self._queue.popleft()
             try:
                 cost = self.calculate_cost(item.span_start_time, item.attributes)
             except Exception as e:
@@ -65,9 +70,6 @@ class SpanCostCalculator(DaemonTask):
                 session.add_all(costs)
         except Exception as e:
             logger.exception(f"Failed to insert costs: {e}")
-        finally:
-            # Clear the queue after processing
-            self._queue.clear()
 
     def put_nowait(self, item: SpanCostCalculatorQueueItem) -> None:
         self._queue.append(item)

phoenix/server/grpc_server.py

@@ -1,5 +1,4 @@
-from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any, Iterable, Optional
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Iterable, Optional
 
 import grpc
 from grpc.aio import RpcContext, Server, ServerInterceptor
@@ -11,6 +10,7 @@ from opentelemetry.proto.collector.trace.v1.trace_service_pb2_grpc import (
     TraceServiceServicer,
     add_TraceServiceServicer_to_server,
 )
+from starlette.concurrency import run_in_threadpool
 from typing_extensions import TypeAlias
 
 from phoenix.auth import CanReadToken
@@ -34,10 +34,10 @@ ProjectName: TypeAlias = str
 class Servicer(TraceServiceServicer):  # type: ignore[misc,unused-ignore]
     def __init__(
         self,
-        callback: Callable[[Span, ProjectName], Awaitable[None]],
+        enqueue_span: Callable[[Span, ProjectName], Awaitable[None]],
     ) -> None:
         super().__init__()
-        self._callback = callback
+        self._enqueue_span = enqueue_span
 
     async def Export(
         self,
@@ -48,22 +48,22 @@ class Servicer(TraceServiceServicer):  # type: ignore[misc,unused-ignore]
             project_name = get_project_name(resource_spans.resource.attributes)
             for scope_span in resource_spans.scope_spans:
                 for otlp_span in scope_span.spans:
-                    span = decode_otlp_span(otlp_span)
-                    await self._callback(span, project_name)
+                    span = await run_in_threadpool(decode_otlp_span, otlp_span)
+                    await self._enqueue_span(span, project_name)
         return ExportTraceServiceResponse()
 
 
 class GrpcServer:
     def __init__(
         self,
-        callback: Callable[[Span, ProjectName], Awaitable[None]],
+        enqueue_span: Callable[[Span, ProjectName], Awaitable[None]],
         tracer_provider: Optional["TracerProvider"] = None,
         enable_prometheus: bool = False,
         disabled: bool = False,
         token_store: Optional[CanReadToken] = None,
         interceptors: Iterable[ServerInterceptor] = (),
     ) -> None:
-        self._callback = callback
+        self._enqueue_span = enqueue_span
         self._server: Optional[Server] = None
         self._tracer_provider = tracer_provider
         self._enable_prometheus = enable_prometheus
@@ -106,7 +106,7 @@ class GrpcServer:
             server.add_secure_port(f"[::]:{get_env_grpc_port()}", server_credentials)
         else:
             server.add_insecure_port(f"[::]:{get_env_grpc_port()}")
-        add_TraceServiceServicer_to_server(Servicer(self._callback), server)  # type: ignore[no-untyped-call,unused-ignore]
+        add_TraceServiceServicer_to_server(Servicer(self._enqueue_span), server)  # type: ignore[no-untyped-call,unused-ignore]
         await server.start()
         self._server = server
 

phoenix/server/prometheus.py

@@ -9,6 +9,7 @@ import psutil
 from prometheus_client import (
     Counter,
     Gauge,
+    Histogram,
     Summary,
     start_http_server,
 )
@@ -36,14 +37,19 @@ CPU_METRIC = Gauge(
     name="cpu_usage_percent",
     documentation="CPU usage percent",
 )
-BULK_LOADER_INSERTION_TIME = Summary(
-    name="bulk_loader_insertion_time_seconds_summary",
-    documentation="Summary of database insertion time (seconds)",
+BULK_LOADER_SPAN_INSERTION_TIME = Histogram(
+    namespace="phoenix",
+    name="bulk_loader_span_insertion_time_seconds",
+    documentation="Histogram of span database insertion time (seconds)",
+    buckets=[0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0, 180.0],  # 500ms to 3min
 )
-BULK_LOADER_SPAN_INSERTIONS = Counter(
-    name="bulk_loader_span_insertions_total",
-    documentation="Total count of bulk loader span insertions",
+
+BULK_LOADER_SPAN_EXCEPTIONS = Counter(
+    namespace="phoenix",
+    name="bulk_loader_span_exceptions_total",
+    documentation="Total count of span insertion exceptions",
 )
+
 BULK_LOADER_EVALUATION_INSERTIONS = Counter(
     name="bulk_loader_evaluation_insertions_total",
     documentation="Total count of bulk loader evaluation insertions",
@@ -95,6 +101,24 @@ DB_DISK_USAGE_WARNING_EMAIL_ERRORS = Counter(
     documentation="Total count of database disk usage warning email send errors",
 )
 
+SPAN_QUEUE_REJECTIONS = Counter(
+    namespace="phoenix",
+    name="span_queue_rejections_total",
+    documentation="Total count of requests rejected due to span queue being full",
+)
+
+SPAN_QUEUE_SIZE = Gauge(
+    namespace="phoenix",
+    name="span_queue_size",
+    documentation="Current number of spans in the processing queue",
+)
+
+BULK_LOADER_LAST_ACTIVITY = Gauge(
+    namespace="phoenix",
+    name="bulk_loader_last_activity_timestamp_seconds",
+    documentation="Unix timestamp when bulk loader last processed items",
+)
+
 
 class PrometheusMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

phoenix/server/static/.vite/manifest.json

@@ -1,73 +1,73 @@
 {
-  "_components-Cs9c4Nxp.js": {
-    "file": "assets/components-Cs9c4Nxp.js",
+  "_components-CdQiQTvs.js": {
+    "file": "assets/components-CdQiQTvs.js",
     "name": "components",
     "imports": [
-      "_vendor-RdRDaQiR.js",
-      "_pages-Cbj9SjBx.js",
-      "_vendor-arizeai-DsYDNOqt.js",
-      "_vendor-codemirror-BzJDUbEx.js",
+      "_vendor-Cfrr9FCF.js",
+      "_pages-CnfZ3RhB.js",
+      "_vendor-arizeai-Dz0kN-lQ.js",
+      "_vendor-codemirror-ClqtONZQ.js",
       "_vendor-three-BLWp5bic.js"
     ]
   },
-  "_pages-Cbj9SjBx.js": {
-    "file": "assets/pages-Cbj9SjBx.js",
+  "_pages-CnfZ3RhB.js": {
+    "file": "assets/pages-CnfZ3RhB.js",
     "name": "pages",
     "imports": [
-      "_vendor-RdRDaQiR.js",
-      "_vendor-arizeai-DsYDNOqt.js",
-      "_components-Cs9c4Nxp.js",
-      "_vendor-codemirror-BzJDUbEx.js",
-      "_vendor-recharts-BTHn5Y2R.js"
+      "_vendor-Cfrr9FCF.js",
+      "_vendor-arizeai-Dz0kN-lQ.js",
+      "_components-CdQiQTvs.js",
+      "_vendor-codemirror-ClqtONZQ.js",
+      "_vendor-recharts-D6kvOpmb.js"
     ]
   },
-  "_vendor-CqDb5u4o.css": {
-    "file": "assets/vendor-CqDb5u4o.css",
-    "src": "_vendor-CqDb5u4o.css"
+  "_vendor-BGzfc4EU.css": {
+    "file": "assets/vendor-BGzfc4EU.css",
+    "src": "_vendor-BGzfc4EU.css"
   },
-  "_vendor-RdRDaQiR.js": {
-    "file": "assets/vendor-RdRDaQiR.js",
+  "_vendor-Cfrr9FCF.js": {
+    "file": "assets/vendor-Cfrr9FCF.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-BLWp5bic.js"
     ],
     "css": [
-      "assets/vendor-CqDb5u4o.css"
+      "assets/vendor-BGzfc4EU.css"
     ]
   },
-  "_vendor-arizeai-DsYDNOqt.js": {
-    "file": "assets/vendor-arizeai-DsYDNOqt.js",
+  "_vendor-arizeai-Dz0kN-lQ.js": {
+    "file": "assets/vendor-arizeai-Dz0kN-lQ.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-RdRDaQiR.js"
+      "_vendor-Cfrr9FCF.js"
     ]
   },
-  "_vendor-codemirror-BzJDUbEx.js": {
-    "file": "assets/vendor-codemirror-BzJDUbEx.js",
+  "_vendor-codemirror-ClqtONZQ.js": {
+    "file": "assets/vendor-codemirror-ClqtONZQ.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-RdRDaQiR.js",
-      "_vendor-shiki-BAcocHFl.js"
+      "_vendor-Cfrr9FCF.js",
+      "_vendor-shiki-xSOiKxt0.js"
     ],
     "dynamicImports": [
-      "_vendor-shiki-BAcocHFl.js",
-      "_vendor-shiki-BAcocHFl.js",
-      "_vendor-shiki-BAcocHFl.js"
+      "_vendor-shiki-xSOiKxt0.js",
+      "_vendor-shiki-xSOiKxt0.js",
+      "_vendor-shiki-xSOiKxt0.js"
     ]
   },
-  "_vendor-recharts-BTHn5Y2R.js": {
-    "file": "assets/vendor-recharts-BTHn5Y2R.js",
+  "_vendor-recharts-D6kvOpmb.js": {
+    "file": "assets/vendor-recharts-D6kvOpmb.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-RdRDaQiR.js"
+      "_vendor-Cfrr9FCF.js"
     ]
   },
-  "_vendor-shiki-BAcocHFl.js": {
-    "file": "assets/vendor-shiki-BAcocHFl.js",
+  "_vendor-shiki-xSOiKxt0.js": {
+    "file": "assets/vendor-shiki-xSOiKxt0.js",
     "name": "vendor-shiki",
     "isDynamicEntry": true,
     "imports": [
-      "_vendor-RdRDaQiR.js"
+      "_vendor-Cfrr9FCF.js"
     ]
   },
   "_vendor-three-BLWp5bic.js": {
@@ -75,19 +75,19 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-D1FDMBMV.js",
+    "file": "assets/index-B1VuXYRI.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-RdRDaQiR.js",
-      "_vendor-arizeai-DsYDNOqt.js",
-      "_pages-Cbj9SjBx.js",
-      "_components-Cs9c4Nxp.js",
+      "_vendor-Cfrr9FCF.js",
+      "_vendor-arizeai-Dz0kN-lQ.js",
+      "_pages-CnfZ3RhB.js",
+      "_components-CdQiQTvs.js",
       "_vendor-three-BLWp5bic.js",
-      "_vendor-codemirror-BzJDUbEx.js",
-      "_vendor-shiki-BAcocHFl.js",
-      "_vendor-recharts-BTHn5Y2R.js"
+      "_vendor-codemirror-ClqtONZQ.js",
+      "_vendor-shiki-xSOiKxt0.js",
+      "_vendor-recharts-D6kvOpmb.js"
     ]
   }
 }