google-cloud-bigtable 2.41.0__tar.gz → 2.43.0__tar.gz

{google_cloud_bigtable-2.41.0/google_cloud_bigtable.egg-info → google_cloud_bigtable-2.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigtable
-Version: 2.41.0
+Version: 2.43.0
 Summary: Google Cloud Bigtable API client library
 Home-page: https://github.com/googleapis/google-cloud-python/tree/main/packages/google-cloud-bigtable
 Author: Google LLC
@@ -21,15 +21,18 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: google-api-core[grpc]<3.0.0,>=2.24.2
+Requires-Dist: google-api-core[grpc]<3.0.0,>=2.25.0
 Requires-Dist: google-auth!=2.24.0,!=2.25.0,<3.0.0,>=2.14.1
 Requires-Dist: grpcio<2.0.0,>=1.59.0
 Requires-Dist: grpcio<2.0.0,>=1.75.1; python_version >= "3.14"
 Requires-Dist: proto-plus<2.0.0,>=1.26.1
 Requires-Dist: protobuf<8.0.0,>=6.33.5
+Requires-Dist: google-cloud-monitoring<3.0.0dev,>=2.0.0
 Requires-Dist: google-cloud-core<3.0.0,>=2.0.0
 Requires-Dist: grpc-google-iam-v1<1.0.0,>=0.14.2
-Requires-Dist: google-crc32c<2.0.0dev,>=1.6.0
+Requires-Dist: google-crc32c<2.0.0,>=1.6.0
+Requires-Dist: opentelemetry-api<2.0.0dev,>=1.0.0
+Requires-Dist: opentelemetry-sdk<2.0.0dev,>=1.0.0
 Provides-Extra: libcst
 Requires-Dist: libcst>=0.2.5; extra == "libcst"
 Dynamic: author

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/batcher.py

@@ -174,13 +174,25 @@ class MutationsBatcher(object):
     request.
 
     This class is not suited for usage in systems where each mutation
-    must be guaranteed to be sent, since calling mutate may only result in an
-    in-memory change. In a case of a system crash, any :class:`DirectRow` remaining in
-    memory will not necessarily be sent to the service, even after the
-    completion of the :func:`mutate()` method.
+    must be guaranteed to be sent, since calling :func:`mutate()` may only
+    result in an in-memory change. Rows are only sent to the service when a size
+    limit is reached, when :func:`flush()` is called explicitly, or when the
+    batcher is closed (:func:`close()` is also registered to run at interpreter
+    exit). There is no time-based background flush. As a result, if the process
+    terminates abruptly -- e.g. a crash, ``SIGKILL``, or ``os._exit`` where the
+    ``atexit`` handler never runs -- any :class:`DirectRow` still buffered in
+    memory is silently dropped and never sent, even after :func:`mutate()`
+    returned.
 
     Note on thread safety: The same :class:`MutationBatcher` cannot be shared by multiple end-user threads.
 
+    .. warning::
+
+       If using ``MutationsBatcher``, please ensure you are using
+       ``google-cloud-bigtable >= 2.42.0``, or consider migrating to the
+       batcher provided by the synchronous/asynchronous data client
+       (:mod:`google.cloud.bigtable.data`).
+
     :type table: class
     :param table: class:`~google.cloud.bigtable.table.Table`.
 
@@ -196,8 +208,9 @@ class MutationsBatcher(object):
         (5 MB).
 
     :type flush_interval: float
-    :param flush_interval: (Optional) The interval (in seconds) between asynchronous flush.
-        Default is 1 second.
+    :param flush_interval: (Deprecated) No longer used. Retained only for
+        backwards compatibility. There is no time-based background flush; see the
+        class docstring for when rows are sent.
 
     :type batch_completed_callback: Callable[list:[`~google.rpc.status_pb2.Status`]] = None
     :param batch_completed_callback: (Optional) A callable for handling responses
@@ -219,8 +232,12 @@ class MutationsBatcher(object):
         self.table = table
         self._executor = concurrent.futures.ThreadPoolExecutor()
         atexit.register(self.close)
-        self._timer = threading.Timer(flush_interval, self.flush)
-        self._timer.start()
+        # ``flush_interval`` is retained for backwards compatibility but is no
+        # longer used: the previous background ``threading.Timer`` was one-shot
+        # (never re-armed), so it fired at most once and could silently drop the
+        # rows it dequeued if that single flush raised on the timer thread.
+        # Flushing now happens only on size thresholds, explicit ``flush()``,
+        # or ``close()`` (also registered via ``atexit``).
         self.flow_control = _FlowControl(
             max_mutations=MAX_OUTSTANDING_ELEMENTS,
             max_mutation_bytes=MAX_OUTSTANDING_BYTES,
@@ -350,6 +367,26 @@ class MutationsBatcher(object):
         processed_rows = self.futures_mapping[future]
         self.flow_control.release(processed_rows)
         del self.futures_mapping[future]
+        # Surface any exception raised inside the async flush. Without this, an
+        # exception raised by ``_flush_rows`` (e.g. a non-retryable RPC error, a
+        # retry deadline, or a response-count mismatch) would be stored on the
+        # future and silently discarded, so the failed mutations would never be
+        # reported to the user -- effectively silent data loss. Per-row errors
+        # from a successful RPC are already recorded in ``self.exceptions`` by
+        # ``_flush_rows``; here the whole batch failed with a single exception,
+        # so record it once per row in the batch to keep the reported error
+        # count aligned with the number of affected mutations.
+        #
+        # A cancelled future is "done", so this callback still runs for it, but
+        # ``future.exception()`` would raise ``CancelledError``. Nothing here
+        # cancels futures today, but guard against it so the callback stays
+        # correct if cancellation is ever introduced.
+        if future.cancelled():
+            return
+        exc = future.exception()
+        if exc is not None:
+            for _ in range(processed_rows.rows_count):
+                self.exceptions.put(exc)
 
     def _row_fits_in_batch(self, row, batch_info):
         """Checks if a row can fit in the current batch.
@@ -405,7 +442,19 @@ class MutationsBatcher(object):
         :raises:
             * :exc:`.batcherMutationsBatchError` if there's any error in the mutations.
         """
-        self.flush()
+        try:
+            self.flush()
+        except MutationsBatchError as exc:
+            for e in exc.exc:
+                self.exceptions.put(e)
+        except Exception as exc:
+            # A failure in this final synchronous flush must not abort cleanup.
+            # If it propagated here it would skip the executor shutdown (leaving
+            # in-flight async flushes un-awaited) and skip draining
+            # self.exceptions, masking every error already captured from
+            # earlier async flushes -- silently discarding those failures.
+            # Record it like any other batch failure and continue.
+            self.exceptions.put(exc)
         self._executor.shutdown(wait=True)
         atexit.unregister(self.close)
         if self.exceptions.qsize() > 0:

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/client.py

@@ -28,6 +28,7 @@ In the hierarchy of API concepts
   :class:`~google.cloud.bigtable.row.Row` (and all the cells in the row)
 """
 
+import copy
 import os
 import warnings
 
@@ -37,7 +38,7 @@ from google.auth.credentials import AnonymousCredentials  # type: ignore
 from google.cloud.client import ClientWithProject  # type: ignore
 from google.cloud.environment_vars import BIGTABLE_EMULATOR  # type: ignore
 
-from google.cloud import bigtable, bigtable_admin_v2, bigtable_v2
+from google.cloud import bigtable, bigtable_admin_v2
 from google.cloud.bigtable.cluster import _CLUSTER_NAME_RE, Cluster
 from google.cloud.bigtable.instance import Instance
 from google.cloud.bigtable_admin_v2.services.bigtable_instance_admin.transports import (
@@ -47,7 +48,6 @@ from google.cloud.bigtable_admin_v2.services.bigtable_table_admin.transports imp
     BigtableTableAdminGrpcTransport,
 )
 from google.cloud.bigtable_admin_v2.types import instance
-from google.cloud.bigtable_v2.services.bigtable.transports import BigtableGrpcTransport
 
 INSTANCE_TYPE_PRODUCTION = instance.Instance.Type.PRODUCTION
 INSTANCE_TYPE_DEVELOPMENT = instance.Instance.Type.DEVELOPMENT
@@ -60,7 +60,6 @@ DATA_SCOPE = "https://www.googleapis.com/auth/bigtable.data"
 READ_ONLY_SCOPE = "https://www.googleapis.com/auth/bigtable.data.readonly"
 """Scope for reading table data."""
 
-_DEFAULT_BIGTABLE_EMULATOR_CLIENT = "google-cloud-bigtable-emulator"
 _GRPC_CHANNEL_OPTIONS = (
     ("grpc.max_send_message_length", -1),
     ("grpc.max_receive_message_length", -1),
@@ -68,6 +67,8 @@ _GRPC_CHANNEL_OPTIONS = (
     ("grpc.keepalive_timeout_ms", 10000),
 )
 
+_DEFAULT_BIGTABLE_EMULATOR_CLIENT = "google-cloud-bigtable-emulator"
+
 
 def _create_gapic_client(client_class, client_options=None, transport=None):
     def inner(self):
@@ -284,18 +285,7 @@ class Client(ClientWithProject):
         :rtype: :class:`.bigtable_v2.BigtableClient`
         :returns: A BigtableClient object.
         """
-        if self._table_data_client is None:
-            transport = self._create_gapic_client_channel(
-                bigtable_v2.BigtableClient,
-                BigtableGrpcTransport,
-            )
-            klass = _create_gapic_client(
-                bigtable_v2.BigtableClient,
-                client_options=self._client_options,
-                transport=transport,
-            )
-            self._table_data_client = klass(self)
-        return self._table_data_client
+        return self._veneer_data_client._gapic_client
 
     @property
     def table_admin_client(self):
@@ -363,6 +353,23 @@ class Client(ClientWithProject):
             self._instance_admin_client = klass(self)
         return self._instance_admin_client
 
+    @property
+    def _veneer_data_client(self):
+        """Getter for the new Data Table API."""
+        if self._table_data_client is None:
+            from google.cloud.bigtable.data import BigtableDataClient
+
+            client_info = copy.copy(self._client_info)
+            client_info.client_library_version = f"{bigtable.__version__}-data-shim"
+            self._table_data_client = BigtableDataClient(
+                project=self.project,
+                credentials=self._credentials,
+                client_options=self._client_options,
+                _client_info=client_info,
+                _disable_background_refresh=True,
+            )
+        return self._table_data_client
+
     def instance(self, instance_id, display_name=None, instance_type=None, labels=None):
         """Factory to create a instance associated with this client.
 

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_async/_mutate_rows.py

@@ -23,7 +23,7 @@ import google.cloud.bigtable.data.exceptions as bt_exceptions
 import google.cloud.bigtable_v2.types.bigtable as types_pb
 from google.cloud.bigtable.data._cross_sync import CrossSync
 from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
-from google.cloud.bigtable.data._metrics import tracked_retry
+from google.cloud.bigtable.data._metrics.tracked_retry import tracked_retry
 
 # mutate_rows requests are limited to this number of mutations
 from google.cloud.bigtable.data.mutations import (
@@ -214,6 +214,18 @@ class _MutateRowsOperationAsync:
                 self._handle_entry_error(idx, exc)
             # bubble up exception to be handled by retry wrapper
             raise
+        # Any entries that were sent but never received a response entry (a
+        # successfully-closed but incomplete stream) must not be treated as
+        # successful. Record a retryable error so idempotent entries are retried
+        # and non-idempotent entries surface as failures instead of being
+        # silently dropped.
+        for idx in active_request_indices.values():
+            self._handle_entry_error(
+                idx,
+                bt_exceptions._MutateRowsIncomplete(
+                    "no response entry received for mutation"
+                ),
+            )
         # check if attempt succeeded, or needs to be retried
         if self.remaining_indices:
             # unfinished work; raise exception to trigger retry

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_async/_read_rows.py

@@ -25,7 +25,7 @@ from google.cloud.bigtable.data._cross_sync import CrossSync
 from google.cloud.bigtable.data._helpers import (
     _attempt_timeout_generator,
 )
-from google.cloud.bigtable.data._metrics import tracked_retry
+from google.cloud.bigtable.data._metrics.tracked_retry import tracked_retry
 from google.cloud.bigtable.data.exceptions import (
     InvalidChunk,
     _ResetRow,

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_async/client.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import abc
 import concurrent.futures
+import logging
 import os
 import random
 import time
@@ -49,10 +50,10 @@ from google.protobuf.internal.enum_type_wrapper import EnumTypeWrapper
 from google.protobuf.message import Message
 from grpc import Channel
 
-from google.cloud.bigtable.client import _DEFAULT_BIGTABLE_EMULATOR_CLIENT
 from google.cloud.bigtable.data._cross_sync import CrossSync
 from google.cloud.bigtable.data._helpers import (
     _CONCURRENCY_LIMIT,
+    _DEFAULT_BIGTABLE_EMULATOR_CLIENT,
     TABLE_DEFAULT,
     _align_timeouts,
     _attempt_timeout_generator,
@@ -64,10 +65,16 @@ from google.cloud.bigtable.data._helpers import (
     _WarmedInstanceKey,
 )
 from google.cloud.bigtable.data._metrics import (
+    ActiveOperationMetric,
     BigtableClientSideMetricsController,
     OperationType,
-    tracked_retry,
 )
+from google.cloud.bigtable.data._metrics.handlers._base import MetricsHandler
+from google.cloud.bigtable.data._metrics.handlers.gcp_exporter import (
+    BigtableMetricsExporter,
+    GoogleCloudMetricsHandler,
+)
+from google.cloud.bigtable.data._metrics.tracked_retry import tracked_retry
 from google.cloud.bigtable.data.exceptions import (
     FailedQueryShardError,
     ShardedReadRowsExceptionGroup,
@@ -159,6 +166,8 @@ if TYPE_CHECKING:
 
 __CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen.client"
 
+_LOGGER = logging.getLogger(__name__)
+
 
 @CrossSync.convert_class(
     sync_name="BigtableDataClient",
@@ -209,9 +218,15 @@ class BigtableDataClientAsync(ClientWithProject):
         """
         if "pool_size" in kwargs:
             warnings.warn("pool_size no longer supported")
-        # set up client info headers for veneer library
-        self.client_info = DEFAULT_CLIENT_INFO
-        self.client_info.client_library_version = self._client_version()
+
+        # set up client info headers for veneer library. _client_info is for internal use only,
+        # for the legacy client shim.
+        if kwargs.get("_client_info"):
+            self.client_info = kwargs["_client_info"]
+        else:
+            self.client_info = DEFAULT_CLIENT_INFO
+            self.client_info.client_library_version = self._client_version()
+
         # parse client options
         if type(client_options) is dict:
             client_options = client_options_lib.from_dict(client_options)
@@ -262,6 +277,31 @@ class BigtableDataClientAsync(ClientWithProject):
                 "is the default."
             )
         self._is_closed = CrossSync.Event()
+        # Private argument, for internal use only
+        self._disable_background_refresh = bool(
+            kwargs.get("_disable_background_refresh", False)
+        )
+        handlers: list[MetricsHandler] = []
+        if self._emulator_host is None:
+            try:
+                # create a metrics exporter using the same client configuration
+                exporter = BigtableMetricsExporter(
+                    credentials=self._credentials,
+                    client_options=client_options,
+                )
+                handlers.append(
+                    GoogleCloudMetricsHandler(
+                        exporter=exporter,
+                        client_version=self._client_version(),
+                    )
+                )
+            except Exception as e:
+                _LOGGER.warning(
+                    "Failed to initialize Google Cloud Metrics Exporter: %s. "
+                    "Client-side metrics will be disabled.",
+                    e,
+                )
+        self._metrics = BigtableClientSideMetricsController(handlers=handlers)
         self.transport = cast(TransportType, self._gapic_client.transport)
         # keep track of active instances to for warmup on channel refresh
         self._active_instances: Set[_WarmedInstanceKey] = set()
@@ -372,6 +412,7 @@ class BigtableDataClientAsync(ClientWithProject):
             not self._channel_refresh_task
             and not self._emulator_host
             and not self._is_closed.is_set()
+            and not self._disable_background_refresh
         ):
             # raise error if not in an event loop in async client
             CrossSync.verify_async_event_loop()
@@ -394,6 +435,7 @@ class BigtableDataClientAsync(ClientWithProject):
         if self._executor:
             self._executor.shutdown(wait=False)
         self._channel_refresh_task = None
+        self._metrics.close()
 
     @CrossSync.convert
     async def _ping_and_warm_instances(
@@ -1109,8 +1151,6 @@ class _DataApiTargetAsync(abc.ABC):
             default_retryable_errors or ()
         )
 
-        self._metrics = BigtableClientSideMetricsController()
-
         try:
             self._register_instance_future = CrossSync.create_task(
                 self.client._register_instance,
@@ -1124,6 +1164,21 @@ class _DataApiTargetAsync(abc.ABC):
                 f"{self.__class__.__name__} must be created within an async event loop context."
             ) from e
 
+    def _create_operation(
+        self, op_type: OperationType, **kwargs
+    ) -> ActiveOperationMetric:
+        table_id = getattr(self, "table_id", None) or getattr(
+            self, "materialized_view_id", None
+        )
+        return self.client._metrics.create_operation(
+            op_type,
+            project_id=self.client.project,
+            instance_id=self.instance_id,
+            table_id=table_id,
+            app_profile_id=self.app_profile_id,
+            **kwargs,
+        )
+
     @property
     @abc.abstractmethod
     def _request_path(self) -> dict[str, str]:
@@ -1189,9 +1244,7 @@ class _DataApiTargetAsync(abc.ABC):
             self,
             operation_timeout=operation_timeout,
             attempt_timeout=attempt_timeout,
-            metric=self._metrics.create_operation(
-                OperationType.READ_ROWS, is_streaming=True
-            ),
+            metric=self._create_operation(OperationType.READ_ROWS, is_streaming=True),
             retryable_exceptions=retryable_excs,
         )
         return row_merger.start_operation()
@@ -1295,9 +1348,7 @@ class _DataApiTargetAsync(abc.ABC):
             self,
             operation_timeout=operation_timeout,
             attempt_timeout=attempt_timeout,
-            metric=self._metrics.create_operation(
-                OperationType.READ_ROWS, is_streaming=False
-            ),
+            metric=self._create_operation(OperationType.READ_ROWS, is_streaming=False),
             retryable_exceptions=retryable_excs,
         )
         results_generator = row_merger.start_operation()
@@ -1512,9 +1563,7 @@ class _DataApiTargetAsync(abc.ABC):
         retryable_excs = _get_retryable_errors(retryable_errors, self)
         predicate = retries.if_exception_type(*retryable_excs)
 
-        with self._metrics.create_operation(
-            OperationType.SAMPLE_ROW_KEYS
-        ) as operation_metric:
+        with self._create_operation(OperationType.SAMPLE_ROW_KEYS) as operation_metric:
 
             @CrossSync.convert
             async def execute_rpc():
@@ -1646,9 +1695,7 @@ class _DataApiTargetAsync(abc.ABC):
             # mutations should not be retried
             predicate = retries.if_exception_type()
 
-        with self._metrics.create_operation(
-            OperationType.MUTATE_ROW
-        ) as operation_metric:
+        with self._create_operation(OperationType.MUTATE_ROW) as operation_metric:
             target = partial(
                 self.client._gapic_client.mutate_row,
                 request=MutateRowRequest(
@@ -1722,7 +1769,7 @@ class _DataApiTargetAsync(abc.ABC):
             mutation_entries,
             operation_timeout,
             attempt_timeout,
-            metric=self._metrics.create_operation(OperationType.BULK_MUTATE_ROWS),
+            metric=self._create_operation(OperationType.BULK_MUTATE_ROWS),
             retryable_exceptions=retryable_excs,
         )
         await operation.start()
@@ -1781,7 +1828,7 @@ class _DataApiTargetAsync(abc.ABC):
             false_case_mutations = [false_case_mutations]
         false_case_list = [m._to_pb() for m in false_case_mutations or []]
 
-        with self._metrics.create_operation(OperationType.CHECK_AND_MUTATE):
+        with self._create_operation(OperationType.CHECK_AND_MUTATE):
             result = await self.client._gapic_client.check_and_mutate_row(
                 request=CheckAndMutateRowRequest(
                     true_mutations=true_case_list,
@@ -1839,7 +1886,7 @@ class _DataApiTargetAsync(abc.ABC):
         if not rules:
             raise ValueError("rules must contain at least one item")
 
-        with self._metrics.create_operation(OperationType.READ_MODIFY_WRITE):
+        with self._create_operation(OperationType.READ_MODIFY_WRITE):
             result = await self.client._gapic_client.read_modify_write_row(
                 request=ReadModifyWriteRowRequest(
                     rules=[rule._to_pb() for rule in rules],
@@ -1860,7 +1907,6 @@ class _DataApiTargetAsync(abc.ABC):
         """
         Called to close the Table instance and release any resources held by it.
         """
-        self._metrics.close()
         if self._register_instance_future:
             self._register_instance_future.cancel()
         self.client._remove_instance_registration(

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_async/mutations_batcher.py

@@ -379,7 +379,7 @@ class MutationsBatcherAsync:
         # flush new entries
         in_process_requests: list[CrossSync.Future[list[FailedMutationEntryError]]] = []
         async for batch, metric in self._flow_control.add_to_flow_with_metrics(
-            new_entries, self._target._metrics
+            new_entries, self._target.client._metrics
         ):
             batch_task = CrossSync.create_task(
                 self._execute_mutate_rows,

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_helpers.py

@@ -47,6 +47,9 @@ ShardedQuery = List[ReadRowsQuery]
 # used by read_rows_sharded to limit how many requests are attempted in parallel
 _CONCURRENCY_LIMIT = 10
 
+# used by every data client as a default project name for testing on Bigtable emulator.
+_DEFAULT_BIGTABLE_EMULATOR_CLIENT = "google-cloud-bigtable-emulator"
+
 # used to identify an active bigtable resource that needs to be warmed through PingAndWarm
 # each instance/app_profile_id pair needs to be individually tracked
 _WarmedInstanceKey = namedtuple(

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_metrics/__init__.py

@@ -19,6 +19,12 @@ from google.cloud.bigtable.data._metrics.data_model import (
     OperationState,
     OperationType,
 )
+from google.cloud.bigtable.data._metrics.handlers.gcp_exporter import (
+    GoogleCloudMetricsHandler,
+)
+from google.cloud.bigtable.data._metrics.handlers.opentelemetry import (
+    OpenTelemetryMetricsHandler,
+)
 from google.cloud.bigtable.data._metrics.metrics_controller import (
     BigtableClientSideMetricsController,
 )
@@ -26,6 +32,8 @@ from google.cloud.bigtable.data._metrics.tracked_retry import tracked_retry
 
 __all__ = (
     "BigtableClientSideMetricsController",
+    "OpenTelemetryMetricsHandler",
+    "GoogleCloudMetricsHandler",
     "OperationType",
     "OperationState",
     "ActiveOperationMetric",

{google_cloud_bigtable-2.41.0 → google_cloud_bigtable-2.43.0}/google/cloud/bigtable/data/_metrics/data_model.py

@@ -118,6 +118,10 @@ class CompletedOperationMetric:
     cluster_id: str
     zone: str
     is_streaming: bool
+    project_id: str | None = None
+    instance_id: str | None = None
+    table_id: str | None = None
+    app_profile_id: str | None = None
     first_response_latency_ns: int | None = None
     flow_throttling_time_ns: int = 0
 
@@ -136,7 +140,6 @@ class ActiveAttemptMetric:
     # time waiting on user to process the response, in nanoseconds
     # currently only relevant for ReadRows
     application_blocking_time_ns: int = 0
-    # backoff time is added to application_blocking_time_ns
     backoff_before_attempt_ns: int = 0
 
 
@@ -160,6 +163,10 @@ class ActiveOperationMetric:
     active_attempt: ActiveAttemptMetric | None = None
     cluster_id: str | None = None
     zone: str | None = None
+    project_id: str | None = None
+    instance_id: str | None = None
+    table_id: str | None = None
+    app_profile_id: str | None = None
     completed_attempts: list[CompletedAttemptMetric] = field(default_factory=list)
     is_streaming: bool = False  # only True for read_rows operations
     handlers: list[MetricsHandler] = field(default_factory=list)
@@ -375,6 +382,10 @@ class ActiveOperationMetric:
             cluster_id=self.cluster_id or DEFAULT_CLUSTER_ID,
             zone=self.zone or DEFAULT_ZONE,
             is_streaming=self.is_streaming,
+            project_id=self.project_id,
+            instance_id=self.instance_id,
+            table_id=self.table_id,
+            app_profile_id=self.app_profile_id,
             first_response_latency_ns=self.first_response_latency_ns,
             flow_throttling_time_ns=self.flow_throttling_time_ns,
         )