Rename Customer Statsbeat to Customer SDKStats (#42573)

* Rename Customer Statsbeat to Customer SDKStats

* Updated CHANGELOG

* Fixed shutdown issue

* Added tests

* Updated CHANGELOG

Author: rads-1996

sdk/monitor/azure-monitor-opentelemetry-exporter/CHANGELOG.md

@@ -11,6 +11,8 @@
   ([#42542](https://github.com/Azure/azure-sdk-for-python/pull/42542))
 - Customer Facing SDKStats: Added the export interval env var for customer sdkstats
   ([#42551](https://github.com/Azure/azure-sdk-for-python/pull/42551))
+- Rename Customer Statsbeat to Customer SDKStats as per [Spec] - https://github.com/aep-health-and-standards/Telemetry-Collection-Spec/pull/581
+  ([#42573](https://github.com/Azure/azure-sdk-for-python/pull/42573))
 
 ### Breaking Changes
 

sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/_constants.py

@@ -146,10 +146,10 @@
 _TRACE = "TRACE"
 _UNKNOWN = "UNKNOWN"
 
-# Customer Facing Statsbeat
-_APPLICATIONINSIGHTS_STATSBEAT_ENABLED_PREVIEW = "APPLICATIONINSIGHTS_STATSBEAT_ENABLED_PREVIEW"
+# Customer Facing SDKStats
+_APPLICATIONINSIGHTS_SDKSTATS_ENABLED_PREVIEW = "APPLICATIONINSIGHTS_SDKSTATS_ENABLED_PREVIEW"
 _APPLICATIONINSIGHTS_SDKSTATS_EXPORT_INTERVAL = "APPLICATIONINSIGHTS_SDKSTATS_EXPORT_INTERVAL"
-_CUSTOMER_STATSBEAT_LANGUAGE = "python"
+_CUSTOMER_SDKSTATS_LANGUAGE = "python"
 
 class DropCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     CLIENT_READONLY = "CLIENT_READONLY"
@@ -167,12 +167,12 @@ class RetryCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
 
 RetryCodeType = Union[RetryCode, int]
 
-class CustomerStatsbeatMetricName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+class CustomerSdkStatsMetricName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     ITEM_SUCCESS_COUNT = "preview.item.success.count"
     ITEM_DROP_COUNT = "preview.item.dropped.count"
     ITEM_RETRY_COUNT = "preview.item.retry.count"
 
-class CustomerStatsbeatProperties:
+class CustomerSdkStatsProperties:
     language: str
     version: str
     compute_type: str

sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/export/_base.py

@@ -1,8 +1,8 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
-"""Customer Statsbeat implementation for Azure Monitor OpenTelemetry Exporter.
+"""Customer SDKStats implementation for Azure Monitor OpenTelemetry Exporter.
 
-This module provides the implementation for collecting and reporting customer statsbeat
+This module provides the implementation for collecting and reporting Customer SDKStats
 metrics that track the usage and performance of the Azure Monitor OpenTelemetry Exporter.
 """
 
@@ -15,14 +15,14 @@
 from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
 
 from azure.monitor.opentelemetry.exporter._constants import (
-    _APPLICATIONINSIGHTS_STATSBEAT_ENABLED_PREVIEW,
-    CustomerStatsbeatProperties,
+    _APPLICATIONINSIGHTS_SDKSTATS_ENABLED_PREVIEW,
+    CustomerSdkStatsProperties,
     DropCode,
     DropCodeType,
     RetryCode,
     RetryCodeType,
-    CustomerStatsbeatMetricName,
-    _CUSTOMER_STATSBEAT_LANGUAGE,
+    CustomerSdkStatsMetricName,
+    _CUSTOMER_SDKSTATS_LANGUAGE,
 )
 
 from azure.monitor.opentelemetry.exporter.export.metrics._exporter import AzureMonitorMetricExporter
@@ -38,23 +38,21 @@
 from azure.monitor.opentelemetry.exporter import VERSION
 
 from azure.monitor.opentelemetry.exporter.statsbeat._state import (
-    _CUSTOMER_STATSBEAT_STATE,
-    _CUSTOMER_STATSBEAT_STATE_LOCK,
+    _CUSTOMER_SDKSTATS_STATE,
+    _CUSTOMER_SDKSTATS_STATE_LOCK,
 )
 
-_CUSTOMER_STATSBEAT_MAP_LOCK = threading.Lock()
-
-class _CustomerStatsbeatTelemetryCounters:
+class _CustomerSdkStatsTelemetryCounters:
     def __init__(self):
         self.total_item_success_count: Dict[str, Any] = {}
         self.total_item_drop_count: Dict[str, Dict[DropCodeType, Dict[str, int]]] = {}
         self.total_item_retry_count: Dict[str, Dict[RetryCodeType, Dict[str, int]]] = {}
 
-class CustomerStatsbeatMetrics(metaclass=Singleton): # pylint: disable=too-many-instance-attributes
+class CustomerSdkStatsMetrics(metaclass=Singleton): # pylint: disable=too-many-instance-attributes
     def __init__(self, connection_string):
-        self._counters = _CustomerStatsbeatTelemetryCounters()
-        self._language = _CUSTOMER_STATSBEAT_LANGUAGE
-        self._is_enabled = os.environ.get(_APPLICATIONINSIGHTS_STATSBEAT_ENABLED_PREVIEW, "").lower() in ("true")
+        self._counters = _CustomerSdkStatsTelemetryCounters()
+        self._language = _CUSTOMER_SDKSTATS_LANGUAGE
+        self._is_enabled = os.environ.get(_APPLICATIONINSIGHTS_SDKSTATS_ENABLED_PREVIEW, "").lower() in ("true")
         if not self._is_enabled:
             return
 
@@ -63,36 +61,36 @@ def __init__(self, connection_string):
             "instrumentation_collection": True,  # Prevent circular dependency
         }
 
-        self._customer_statsbeat_exporter = AzureMonitorMetricExporter(**exporter_config)
-        self._customer_statsbeat_exporter._is_customer_statsbeat = True
+        self._customer_sdkstats_exporter = AzureMonitorMetricExporter(**exporter_config)
+        self._customer_sdkstats_exporter._is_customer_sdkstats = True
         metric_reader_options = {
-            "exporter": self._customer_statsbeat_exporter,
+            "exporter": self._customer_sdkstats_exporter,
             "export_interval_millis": _get_customer_sdkstats_export_interval()
         }
-        self._customer_statsbeat_metric_reader = PeriodicExportingMetricReader(**metric_reader_options)
-        self._customer_statsbeat_meter_provider = MeterProvider(
-            metric_readers=[self._customer_statsbeat_metric_reader]
+        self._customer_sdkstats_metric_reader = PeriodicExportingMetricReader(**metric_reader_options)
+        self._customer_sdkstats_meter_provider = MeterProvider(
+            metric_readers=[self._customer_sdkstats_metric_reader]
         )
-        self._customer_statsbeat_meter = self._customer_statsbeat_meter_provider.get_meter(__name__)
+        self._customer_sdkstats_meter = self._customer_sdkstats_meter_provider.get_meter(__name__)
 
-        self._customer_properties = CustomerStatsbeatProperties(
+        self._customer_properties = CustomerSdkStatsProperties(
             language=self._language,
             version=VERSION,
             compute_type=get_compute_type(),
         )
 
-        self._success_gauge = self._customer_statsbeat_meter.create_observable_gauge(
-            name=CustomerStatsbeatMetricName.ITEM_SUCCESS_COUNT.value,
+        self._success_gauge = self._customer_sdkstats_meter.create_observable_gauge(
+            name=CustomerSdkStatsMetricName.ITEM_SUCCESS_COUNT.value,
             description="Tracks successful telemetry items sent to Azure Monitor",
             callbacks=[self._item_success_callback]
         )
-        self._dropped_gauge = self._customer_statsbeat_meter.create_observable_gauge(
-            name=CustomerStatsbeatMetricName.ITEM_DROP_COUNT.value,
+        self._dropped_gauge = self._customer_sdkstats_meter.create_observable_gauge(
+            name=CustomerSdkStatsMetricName.ITEM_DROP_COUNT.value,
             description="Tracks dropped telemetry items sent to Azure Monitor",
             callbacks=[self._item_drop_callback]
         )
-        self._retry_gauge = self._customer_statsbeat_meter.create_observable_gauge(
-            name=CustomerStatsbeatMetricName.ITEM_RETRY_COUNT.value,
+        self._retry_gauge = self._customer_sdkstats_meter.create_observable_gauge(
+            name=CustomerSdkStatsMetricName.ITEM_RETRY_COUNT.value,
             description="Tracks retry attempts for telemetry items sent to Azure Monitor",
             callbacks=[self._item_retry_callback]
         )
@@ -236,44 +234,44 @@ def _get_retry_reason(self, retry_code: RetryCodeType, exception_message: Option
         }
         return retry_code_reasons.get(retry_code, "unknown_reason")
 
-# Global customer statsbeat singleton
-_CUSTOMER_STATSBEAT_METRICS = None
-_CUSTOMER_STATSBEAT_LOCK = threading.Lock()
+# Global customer sdkstats singleton
+_CUSTOMER_SDKSTATS_METRICS = None
+_CUSTOMER_SDKSTATS_LOCK = threading.Lock()
 
 
 # pylint: disable=global-statement
 # pylint: disable=protected-access
-def collect_customer_statsbeat(exporter):
-    global _CUSTOMER_STATSBEAT_METRICS
-    # Only start customer statsbeat if did not exist before
-    if _CUSTOMER_STATSBEAT_METRICS is None:
-        with _CUSTOMER_STATSBEAT_LOCK:
+def collect_customer_sdkstats(exporter):
+    global _CUSTOMER_SDKSTATS_METRICS
+    # Only start customer sdkstats if did not exist before
+    if _CUSTOMER_SDKSTATS_METRICS is None:
+        with _CUSTOMER_SDKSTATS_LOCK:
             # Double-check inside the lock to avoid race conditions
-            if _CUSTOMER_STATSBEAT_METRICS is None:
+            if _CUSTOMER_SDKSTATS_METRICS is None:
 
                 connection_string = (
                     f"InstrumentationKey={exporter._instrumentation_key};"
                     f"IngestionEndpoint={exporter._endpoint}"
                 )
-                _CUSTOMER_STATSBEAT_METRICS = CustomerStatsbeatMetrics(connection_string)
+                _CUSTOMER_SDKSTATS_METRICS = CustomerSdkStatsMetrics(connection_string)
 
-    exporter._customer_statsbeat_metrics = _CUSTOMER_STATSBEAT_METRICS
+    exporter._customer_sdkstats_metrics = _CUSTOMER_SDKSTATS_METRICS
     if hasattr(exporter, 'storage') and exporter.storage:
-        exporter.storage._customer_statsbeat_metrics = _CUSTOMER_STATSBEAT_METRICS
+        exporter.storage._customer_sdkstats_metrics = _CUSTOMER_SDKSTATS_METRICS
 
 
-def shutdown_customer_statsbeat_metrics() -> None:
-    global _CUSTOMER_STATSBEAT_METRICS
+def shutdown_customer_sdkstats_metrics() -> None:
+    global _CUSTOMER_SDKSTATS_METRICS
     shutdown_success = False
-    if _CUSTOMER_STATSBEAT_METRICS is not None:
-        with _CUSTOMER_STATSBEAT_LOCK:
+    if _CUSTOMER_SDKSTATS_METRICS is not None:
+        with _CUSTOMER_SDKSTATS_LOCK:
             try:
-                if _CUSTOMER_STATSBEAT_METRICS._meter_provider is not None:
-                    _CUSTOMER_STATSBEAT_METRICS._meter_provider.shutdown()
-                    _CUSTOMER_STATSBEAT_METRICS = None
+                if _CUSTOMER_SDKSTATS_METRICS._customer_sdkstats_meter_provider is not None:
+                    _CUSTOMER_SDKSTATS_METRICS._customer_sdkstats_meter_provider.shutdown()
+                    _CUSTOMER_SDKSTATS_METRICS = None
                     shutdown_success = True
             except:  # pylint: disable=bare-except
                 pass
         if shutdown_success:
-            with _CUSTOMER_STATSBEAT_STATE_LOCK:
-                _CUSTOMER_STATSBEAT_STATE["SHUTDOWN"] = True
+            with _CUSTOMER_SDKSTATS_STATE_LOCK:
+                _CUSTOMER_SDKSTATS_STATE["SHUTDOWN"] = True

sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/statsbeat/_customer_statsbeat.py renamed to sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/statsbeat/_customer_sdkstats.py

@@ -19,10 +19,10 @@
 _STATSBEAT_STATE_LOCK = threading.Lock()
 _STATSBEAT_FAILURE_COUNT_THRESHOLD = 3
 
-_CUSTOMER_STATSBEAT_STATE = {
+_CUSTOMER_SDKSTATS_STATE = {
     "SHUTDOWN": False,
 }
-_CUSTOMER_STATSBEAT_STATE_LOCK = threading.Lock()
+_CUSTOMER_SDKSTATS_STATE_LOCK = threading.Lock()
 
 _LOCAL_STORAGE_SETUP_STATE = {
     "READONLY": False,
@@ -80,8 +80,8 @@ def set_statsbeat_live_metrics_feature_set():
     with _STATSBEAT_STATE_LOCK:
         _STATSBEAT_STATE["LIVE_METRICS_FEATURE_SET"] = True
 
-def get_customer_statsbeat_shutdown():
-    return _CUSTOMER_STATSBEAT_STATE["SHUTDOWN"]
+def get_customer_sdkstats_shutdown():
+    return _CUSTOMER_SDKSTATS_STATE["SHUTDOWN"]
 
 def get_local_storage_setup_state_readonly():
     return _LOCAL_STORAGE_SETUP_STATE["READONLY"]

sdk/monitor/azure-monitor-opentelemetry-exporter/azure/monitor/opentelemetry/exporter/statsbeat/_state.py

@@ -121,85 +121,85 @@ def _determine_client_retry_code(error) -> Tuple[RetryCodeType, Optional[str]]:
         return (RetryCode.CLIENT_TIMEOUT, error_message)
     return (RetryCode.CLIENT_EXCEPTION, error_message)
 
-def _track_successful_items(customer_statsbeat_metrics, envelopes: List[TelemetryItem]):
-    if customer_statsbeat_metrics:
+def _track_successful_items(customer_sdkstats_metrics, envelopes: List[TelemetryItem]):
+    if customer_sdkstats_metrics:
         for envelope in envelopes:
             telemetry_type = _get_telemetry_type(envelope)
-            customer_statsbeat_metrics.count_successful_items(
+            customer_sdkstats_metrics.count_successful_items(
                 1,
                 telemetry_type
             )
 
 def _track_dropped_items(
-        customer_statsbeat_metrics,
+        customer_sdkstats_metrics,
         envelopes: List[TelemetryItem],
         drop_code: DropCodeType,
         error_message: Optional[str] = None
     ):
-    if customer_statsbeat_metrics:
+    if customer_sdkstats_metrics:
         if error_message is None:
             for envelope in envelopes:
                 telemetry_type = _get_telemetry_type(envelope)
-                customer_statsbeat_metrics.count_dropped_items(
+                customer_sdkstats_metrics.count_dropped_items(
                     1,
                     telemetry_type,
                     drop_code
                 )
         else:
             for envelope in envelopes:
                 telemetry_type = _get_telemetry_type(envelope)
-                customer_statsbeat_metrics.count_dropped_items(
+                customer_sdkstats_metrics.count_dropped_items(
                     1,
                     telemetry_type,
                     drop_code,
                     error_message
                 )
 
-def _track_retry_items(customer_statsbeat_metrics, envelopes: List[TelemetryItem], error) -> None:
-    if customer_statsbeat_metrics:
+def _track_retry_items(customer_sdkstats_metrics, envelopes: List[TelemetryItem], error) -> None:
+    if customer_sdkstats_metrics:
         retry_code, message = _determine_client_retry_code(error)
         for envelope in envelopes:
             telemetry_type = _get_telemetry_type(envelope)
             if isinstance(retry_code, int):
                 # For status codes, include the message if available
                 if message:
-                    customer_statsbeat_metrics.count_retry_items(
+                    customer_sdkstats_metrics.count_retry_items(
                         1,
                         telemetry_type,
                         retry_code,
                         str(message)
                     )
                 else:
-                    customer_statsbeat_metrics.count_retry_items(
+                    customer_sdkstats_metrics.count_retry_items(
                         1,
                         telemetry_type,
                         retry_code
                     )
             else:
-                customer_statsbeat_metrics.count_retry_items(
+                customer_sdkstats_metrics.count_retry_items(
                     1,
                     telemetry_type,
                     retry_code,
                     str(message)
                 )
 
-def _track_dropped_items_from_storage(customer_statsbeat_metrics, result_from_storage_put, envelopes):
-    if customer_statsbeat_metrics:
+def _track_dropped_items_from_storage(customer_sdkstats_metrics, result_from_storage_put, envelopes):
+    if customer_sdkstats_metrics:
         if result_from_storage_put == StorageExportResult.CLIENT_STORAGE_DISABLED:
             # Track items that would have been retried but are dropped since client has local storage disabled
-            _track_dropped_items(customer_statsbeat_metrics, envelopes, DropCode.CLIENT_STORAGE_DISABLED)
+            _track_dropped_items(customer_sdkstats_metrics, envelopes, DropCode.CLIENT_STORAGE_DISABLED)
         elif result_from_storage_put == StorageExportResult.CLIENT_READONLY:
-            # If filesystem is readonly, track dropped items in customer statsbeat
-            _track_dropped_items(customer_statsbeat_metrics, envelopes, DropCode.CLIENT_READONLY)
+            # If filesystem is readonly, track dropped items in customer sdkstats
+            _track_dropped_items(customer_sdkstats_metrics, envelopes, DropCode.CLIENT_READONLY)
         elif result_from_storage_put == StorageExportResult.CLIENT_PERSISTENCE_CAPACITY_REACHED:
             # If data has to be dropped due to persistent storage being full, track dropped items
-            _track_dropped_items(customer_statsbeat_metrics, envelopes, DropCode.CLIENT_PERSISTENCE_CAPACITY)
+            _track_dropped_items(customer_sdkstats_metrics, envelopes, DropCode.CLIENT_PERSISTENCE_CAPACITY)
         elif get_local_storage_setup_state_exception() != "":
             # For exceptions caught in _check_and_set_folder_permissions during storage setup
-            _track_dropped_items(customer_statsbeat_metrics, envelopes, DropCode.CLIENT_EXCEPTION, result_from_storage_put) # pylint: disable=line-too-long
+            _track_dropped_items(customer_sdkstats_metrics, envelopes, DropCode.CLIENT_EXCEPTION, result_from_storage_put) # pylint: disable=line-too-long
         elif isinstance(result_from_storage_put, str):
             # For any exceptions occurred in put method of either LocalFileStorage or LocalFileBlob, track dropped item with reason # pylint: disable=line-too-long
-            _track_dropped_items(customer_statsbeat_metrics, envelopes, DropCode.CLIENT_EXCEPTION, result_from_storage_put) # pylint: disable=line-too-long
+            _track_dropped_items(customer_sdkstats_metrics, envelopes, DropCode.CLIENT_EXCEPTION, result_from_storage_put) # pylint: disable=line-too-long
         else:
             # LocalFileBlob.put returns StorageExportResult.LOCAL_FILE_BLOB_SUCCESS here. Don't need to track anything in this case. # pylint: disable=line-too-long
             pass