ibm-appconfiguration-python-sdk 0.4.4__tar.gz → 0.5.0__tar.gz

{ibm_appconfiguration_python_sdk-0.4.4/ibm_appconfiguration_python_sdk.egg-info → ibm_appconfiguration_python_sdk-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-appconfiguration-python-sdk
-Version: 0.4.4
+Version: 0.5.0
 Summary: IBM Cloud App Configuration Python SDK
 Home-page: https://github.com/IBM/appconfiguration-python-sdk
 Author: IBM

{ibm_appconfiguration_python_sdk-0.4.4 → ibm_appconfiguration_python_sdk-0.5.0}/ibm_appconfiguration/appconfiguration.py

@@ -290,4 +290,13 @@ class AppConfiguration:
         """
         if self.__configuration_handler_instance is None:
             return False
-        return self.__configuration_handler_instance.is_connected()
+        return self.__configuration_handler_instance.is_connected()
+
+    def flush_records(self):
+        """Immediately sends all pending analytics data (guarded rollout
+        evaluations and metric events) to the App Configuration service,
+        without waiting for the next scheduled flush. Safe to call at any
+        time, including on shutdown.
+        """
+        if self.__is_initialized and self.__is_initialized_configuration:
+            self.__configuration_handler_instance.flush_analytics()

{ibm_appconfiguration_python_sdk-0.4.4 → ibm_appconfiguration_python_sdk-0.5.0}/ibm_appconfiguration/configurations/configuration_handler.py

@@ -20,6 +20,8 @@ import os
 from typing import Dict, List, Any
 from threading import Timer, Thread
 from ibm_appconfiguration.configurations.internal.common import config_messages, config_constants
+from .internal.utils.analytics import Analytics
+from .internal.utils.analytics_record import EventType
 from .internal.utils.logger import Logger
 from .internal.utils.parser import extract_configurations, format_config
 from .internal.utils.validators import Validators
@@ -122,6 +124,10 @@ class ConfigurationHandler:
                                            override_service_url=self.__override_service_url,
                                            use_private_endpoint=self.__use_private_endpoint)
         Metering.get_instance().set_metering_url(URLBuilder.get_metering_path())
+        analytics = Analytics.get_instance()
+        analytics.set_context(environment_id=environment_id, collection_id=collection_id)
+        analytics.set_analytics_url(URLBuilder.get_analytics_path())
+        analytics.start()
         self.__api_manager = APIManager.get_instance()
         self.__live_config_update_enabled = options['live_config_update_enabled']
         self.__bootstrap_file = options['bootstrap_file']
@@ -357,6 +363,97 @@ class ConfigurationHandler:
             self.record_valuation(property_id=property_id, feature_id=None, entity_id=entity_id,
                                   evaluated_segment_id=result_dict['evaluated_segment_id'])
 
+    @staticmethod
+    def get_feature_normalised_value(feature: Feature, entity_id: str) -> int:
+        colon = ':'
+        match feature.get_rollout_type():
+            case config_constants.MANUAL:
+                key = colon.join([entity_id, feature.get_feature_id()])
+            case config_constants.PROGRESSIVE:
+                key = colon.join([
+                    entity_id,
+                    feature.get_feature_id(),
+                    feature.get_rollout_configuration().get('start_at', '')
+                    if feature.get_rollout_configuration() is not None else ''
+                ])
+            case config_constants.GUARDED:
+                key = colon.join([
+                    entity_id,
+                    feature.get_feature_id(),
+                    feature.get_rollout_id()
+                ])
+            case _:
+                key = entity_id
+        return get_normalized_value(key)
+
+    @staticmethod
+    def get_rule_normalised_value(rule: SegmentRules, feature_id: str, entity_id: str, start_at: str = None):
+        colon = ':'
+        match rule.get_rollout_type():
+            case config_constants.MANUAL:
+                key = colon.join([entity_id, feature_id])
+            case config_constants.PROGRESSIVE:
+                key = colon.join([
+                    entity_id,
+                    feature_id,
+                    start_at if start_at is not None else ''
+                ])
+            case config_constants.GUARDED:
+                key = colon.join([
+                    entity_id,
+                    feature_id,
+                    rule.get_rollout_id()
+                ])
+            case _:
+                key = entity_id
+        return get_normalized_value(key)
+
+
+    @staticmethod
+    def add_guarded_evaluation_entry(rollout_id: str, entity_id: str, rollout_percentage: int, normalised_value: int):
+        metric = {
+            'rollout_id': rollout_id,
+            'entity_id': entity_id,
+        }
+        if 0 <= normalised_value < rollout_percentage:
+            # enabled value was served to user and needs to be tracked
+            metric['value_served'] = 'target'
+        elif normalised_value >= 100 - rollout_percentage:
+            # disabled value was served to user and needs to be tracked
+            metric['value_served'] = 'original'
+        else:
+            # this evaluation should not be tracked as it is not part of control group
+            return
+        Analytics.get_instance().add_metric(metric, EventType.GUARDED_EVALUATION)
+
+    @staticmethod
+    def add_guarded_metric_entry(
+            entity_id: str,
+            feature_id: str,
+            rollout_id: str,
+            event_key: str,
+            metrics: list[dict[str, str]],
+            rollout_percentage: int
+    ):
+        metric = {
+            'rollout_id': rollout_id,
+            'entity_id': entity_id,
+            'event_key': event_key,
+            'metrics': metrics
+        }
+        normalised_value = get_normalized_value(':'.join([entity_id, feature_id, rollout_id]))
+        if 0 <= normalised_value < rollout_percentage:
+            # enabled value was served to user and needs to be tracked
+            metric['value_served'] = 'target'
+        elif normalised_value >= 100 - rollout_percentage:
+            # disabled value was served to user and needs to be tracked
+            metric['value_served'] = 'original'
+        else:
+            # this evaluation should not be tracked as it is not part of control group
+            return
+        Analytics.get_instance().add_metric(metric, EventType.GUARDED_METRIC)
+
+
     def feature_evaluation(self, feature: Feature, is_enabled: bool, entity_id: str,
                            entity_attributes: dict = None) -> Any:
         """Feature evaluation method
@@ -386,19 +483,20 @@ class ConfigurationHandler:
                     return result_dict['value'], result_dict['is_enabled']
 
                 # Check feature-level rollout
-                rollout_percentage = None
-                if feature.get_rollout_configuration() is not None:
+                if feature.get_rollout_type() == config_constants.PROGRESSIVE and feature.get_rollout_configuration() is not None:
                     rollout_map = self.__rollout_config_map.get(feature.get_feature_id())
                     if rollout_map:
-                        entity_id += feature.get_rollout_configuration().get('start_at')
                         rollout_percentage = get_current_rollout_percentage(rollout_map)
                     else:
                         rollout_percentage = 0
                 else:
                     rollout_percentage = feature.get_rollout_percentage() if feature.get_rollout_percentage() is not None else 100
 
-                if rollout_percentage == 100 or (get_normalized_value(
-                        entity_id + ":" + feature.get_feature_id()) < rollout_percentage):
+                normalised_value = ConfigurationHandler.get_feature_normalised_value(feature, entity_id)
+                if feature.get_rollout_type() == config_constants.GUARDED:
+                    # if guarded rollout add evaluation entry
+                    self.add_guarded_evaluation_entry(feature.get_rollout_id(), entity_id, rollout_percentage, normalised_value)
+                if rollout_percentage == 100 or normalised_value < rollout_percentage:
                     return feature.get_enabled_value(), True
                 return feature.get_disabled_value(), False
             return feature.get_disabled_value(), False
@@ -429,25 +527,18 @@ class ConfigurationHandler:
                                 result_dict['evaluated_segment_id'] = segment_key
                                 if feature is not None:
                                     # evaluate_rules was called for feature flag
-                                    segment_rollout_percentage = None
-                                    
                                     # Check if segment rule has progressive rollout
-                                    if segment_rule.get_rollout_configuration() is not None or segment_rule.get_rollout_type() == config_constants.PROGRESSIVE:
-                                        # Determine which rollout map to use
-                                        if segment_rule.get_rollout_percentage() == config_constants.DEFAULT_ROLLOUT_PERCENTAGE:
-                                            # Use feature-level rollout
-                                            rollout_map = self.__rollout_config_map.get(feature.get_feature_id())
+                                    start_at = None
+                                    if segment_rule.get_rollout_type() == config_constants.PROGRESSIVE:
+                                        # Use segment-level rollout
+                                        start_at = segment_rule.get_rollout_configuration().get('start_at', '')
+                                        rule_id = segment_rule.get_rule_id()
+                                        if rule_id:
+                                            key = feature.get_feature_id() + config_constants.DELIMITER + rule_id
+                                            rollout_map = self.__rollout_config_map.get(key)
                                         else:
-                                            # Use segment-level rollout
-                                            rule_id = segment_rule.get_rule_id()
-                                            if rule_id:
-                                                key = feature.get_feature_id() + config_constants.DELIMITER + rule_id
-                                                rollout_map = self.__rollout_config_map.get(key)
-                                            else:
-                                                rollout_map = None
-                                        
+                                             rollout_map = None
                                         if rollout_map:
-                                            entity_id += segment_rule.get_rollout_configuration().get('start_at')
                                             segment_rollout_percentage = get_current_rollout_percentage(rollout_map)
                                         else:
                                             segment_rollout_percentage = 0
@@ -457,9 +548,16 @@ class ConfigurationHandler:
                                             segment_rollout_percentage = feature.get_rollout_percentage() if feature.get_rollout_percentage() is not None else 100
                                         else:
                                             segment_rollout_percentage = segment_rule.get_rollout_percentage() if segment_rule.get_rollout_percentage() is not None else 100
-                                    
-                                    if segment_rollout_percentage == 100 or (get_normalized_value(
-                                            entity_id + ":" + feature.get_feature_id())) < segment_rollout_percentage:
+
+                                    normalised_value = ConfigurationHandler.get_rule_normalised_value(segment_rule, feature.get_feature_id(), entity_id, start_at)
+                                    if segment_rule.get_rollout_type() == config_constants.GUARDED:
+                                        ConfigurationHandler.add_guarded_evaluation_entry(
+                                            segment_rule.get_rollout_id(),
+                                            entity_id,
+                                            segment_rollout_percentage,
+                                            normalised_value
+                                        )
+                                    if segment_rollout_percentage == 100 or normalised_value < segment_rollout_percentage:
                                         if segment_rule.get_value() == config_constants.DEFAULT_FEATURE_VALUE:
                                             result_dict['value'] = feature.get_enabled_value()
                                         else:
@@ -480,19 +578,20 @@ class ConfigurationHandler:
 
         if feature is not None:
             # Check feature-level rollout
-            rollout_percentage = None
-            if feature.get_rollout_configuration() is not None:
+            if feature.get_rollout_type() == config_constants.PROGRESSIVE and feature.get_rollout_configuration() is not None:
                 rollout_map = self.__rollout_config_map.get(feature.get_feature_id())
                 if rollout_map:
-                    entity_id += feature.get_rollout_configuration().get('start_at')
                     rollout_percentage = get_current_rollout_percentage(rollout_map)
                 else:
                     rollout_percentage = 0
             else:
                 rollout_percentage = feature.get_rollout_percentage() if feature.get_rollout_percentage() is not None else 100
-            
-            if rollout_percentage == 100 or get_normalized_value(
-                    entity_id + ":" + feature.get_feature_id()) < rollout_percentage:
+
+            normalised_value = ConfigurationHandler.get_feature_normalised_value(feature, entity_id)
+            if feature.get_rollout_type() == config_constants.GUARDED:
+                # if guarded rollout add evaluation entry
+                self.add_guarded_evaluation_entry(feature.get_rollout_id(), entity_id, rollout_percentage, normalised_value)
+            if rollout_percentage == 100 or normalised_value < rollout_percentage:
                 result_dict['value'] = feature.get_enabled_value()
                 result_dict['is_enabled'] = True
             else:
@@ -601,3 +700,7 @@ class ConfigurationHandler:
         Returns: boolean indicating connection status
         """
         return self.__socket.is_connected()
+
+    def flush_analytics(self):
+        """Immediately flush all pending analytics data."""
+        Analytics.get_instance().flush()

{ibm_appconfiguration_python_sdk-0.4.4 → ibm_appconfiguration_python_sdk-0.5.0}/ibm_appconfiguration/configurations/internal/common/config_constants.py

@@ -29,4 +29,5 @@ CUSTOM_SOCKET_CLOSE_REASON_CODE = 4001
 
 MANUAL = 'MANUAL'
 PROGRESSIVE = 'PROGRESSIVE'
+GUARDED = 'GUARDED'
 DELIMITER = '\u001F'

ibm_appconfiguration_python_sdk-0.5.0/ibm_appconfiguration/configurations/internal/utils/analytics.py

@@ -0,0 +1,214 @@
+# Copyright 2021 IBM All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module provides methods that perform analytics related operations.
+"""
+from datetime import datetime, timezone
+from threading import Event, Lock, Thread
+from time import time
+from typing import Any
+
+from ibm_appconfiguration.configurations.internal.common import config_messages
+from ibm_appconfiguration.configurations.internal.utils.analytics_record import AnalyticsRecord, EventType
+from ibm_appconfiguration.configurations.internal.utils.api_manager import APIManager
+from ibm_appconfiguration.configurations.internal.utils.logger import Logger
+
+
+class Analytics:
+    """Class to send the Analytic data.
+
+    Thread-safety model
+    -------------------
+    One lock (``__record_lock``) serialises all reads and writes on
+    ``__record``.  ``AnalyticsRecord`` itself is intentionally NOT
+    thread-safe — the lock lives here so we can do atomic check-then-act
+    sequences (e.g. *exceeds_limit → split_head*) without TOCTOU gaps.
+
+    A second lock (``__flush_lock``) ensures that at most one thread is
+    running the drain/flush pipeline at a time.  This prevents the
+    background job and a concurrent ``flush()`` call from both splitting
+    the same data and sending it twice.
+    """
+
+    __send_interval = 5 * 60  # mandatory flush every 5 minutes
+    __batch_size = 30         # max usages the server accepts per request
+    __instance = None
+
+    @staticmethod
+    def get_instance():
+        """ Static access method. """
+        if Analytics.__instance is None:
+            return Analytics()
+        return Analytics.__instance
+
+    def __init__(self):
+        """ Virtually private constructor. """
+        if Analytics.__instance is not None:
+            raise Exception("Analytics " + config_messages.SINGLETON_EXCEPTION)
+        self.__environment_id = None
+        self.__collection_id = None
+        self.__analytics_url = None
+        # Guards all access to __record.
+        self.__record_lock = Lock()
+        self.__record = AnalyticsRecord()
+        self.__job_flag = False
+        # Wakes the background flush thread early (batch-full or stop).
+        self.__flush_event = Event()
+        # Serialises concurrent drain/flush pipelines (background vs flush()).
+        self.__flush_lock = Lock()
+        Analytics.__instance = self
+
+    def set_context(self, environment_id: str, collection_id: str):
+        self.__environment_id = environment_id
+        self.__collection_id = collection_id
+
+    def set_analytics_url(self, url: str):
+        """Set the analytics url."""
+        self.__analytics_url = url
+
+    def add_metric(self, metric: dict[str, Any], metric_type: EventType):
+        metric["timestamp"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        with self.__record_lock:
+            self.__record.add(metric, metric_type)
+            if self.__record.exceeds_limit(Analytics.__batch_size):
+                self.__flush_event.set()
+
+    def __send_to_server(self, record: AnalyticsRecord, previous_delay: int = 0) -> int:
+        """POST *record* to the server.  Returns 0 on success or seconds to
+        wait before retrying."""
+        api_manager = APIManager.get_instance()
+        response = api_manager.prepare_api_request(
+            method="POST",
+            url=self.__analytics_url,
+            data=record.get_request_body(self.__environment_id, self.__collection_id)
+        )
+        status_code = response.get_status_code()
+        if 200 <= status_code < 300:
+            Logger.info("Successfully posted analytics data")
+            return 0
+        if status_code == 429:
+            Logger.warning("Analytics endpoint has been rate-limited, retrying after 30 sec")
+            return 30
+        next_delay = min(600, previous_delay * 2 if previous_delay > 0 else 60)
+        Logger.error(f"Error while posting analytics data, retrying after {next_delay}sec")
+        return next_delay
+
+    def __send_batch(self, batch: AnalyticsRecord):
+        """Send *batch* with retry + merge-back on failure.
+
+        On each failure:
+          1. Merge the failed batch back into the live record (under lock)
+             so no data is stranded while we sleep.
+          2. Sleep for the back-off delay (woken early by flush_event).
+          3. Re-split from the now-merged (and possibly larger) live record
+             so any entries added during the sleep are included next time.
+        """
+        if len(batch) == 0:
+            return
+        previous_delay = 0
+        while True:
+            delay = self.__send_to_server(batch, previous_delay)
+            if delay == 0:
+                return
+            # Merge back before sleeping so data is never orphaned.
+            with self.__record_lock:
+                self.__record.merge(batch)
+            previous_delay = delay
+            self.__flush_event.wait(timeout=delay)
+            self.__flush_event.clear()
+            # Re-split including any entries that arrived during the sleep.
+            # Guard: if another flush() drained the record while we slept,
+            # there is nothing left to send — exit cleanly.
+            with self.__record_lock:
+                if len(self.__record) == 0:
+                    return
+                batch = self.__record.split_head(Analytics.__batch_size)
+
+    def __drain_chunks(self):
+        """Send all full batches (≥ batch_size) one at a time, oldest first.
+
+        Must be called while holding ``__flush_lock``.
+        Leaves any remainder below batch_size in the live record.
+        """
+        while True:
+            with self.__record_lock:
+                if not self.__record.exceeds_limit(Analytics.__batch_size):
+                    break
+                batch = self.__record.split_head(Analytics.__batch_size)
+            self.__send_batch(batch)
+
+    def __flush_remainder(self):
+        """Send whatever is left in the record (< batch_size entries).
+
+        Must be called while holding ``__flush_lock``.
+        """
+        with self.__record_lock:
+            n = len(self.__record)
+            if n == 0:
+                return
+            batch = self.__record.split_head(n)
+        self.__send_batch(batch)
+
+    def __send_analytic_job(self):
+        last_flush = time()
+
+        while self.__job_flag:
+            remaining = Analytics.__send_interval - (time() - last_flush)
+            # Skip sleep entirely when the record is already at the limit.
+            with self.__record_lock:
+                already_full = self.__record.exceeds_limit(Analytics.__batch_size)
+            if remaining > 0 and not already_full:
+                self.__flush_event.wait(timeout=remaining)
+                self.__flush_event.clear()
+
+            if not self.__job_flag:
+                break
+
+            five_min_due = (time() - last_flush) >= Analytics.__send_interval
+
+            # Re-check under lock — state may have changed while we slept.
+            with self.__record_lock:
+                is_full = self.__record.exceeds_limit(Analytics.__batch_size)
+                has_data = len(self.__record) > 0
+
+            if is_full:
+                with self.__flush_lock:
+                    self.__drain_chunks()
+            elif five_min_due and has_data:
+                with self.__flush_lock:
+                    self.__flush_remainder()
+            last_flush = time()
+            # Woken early but record < batch_size and 5-min not due: loop
+            # back and sleep for the remaining interval.
+
+    def start(self):
+        if self.__job_flag:
+            return
+        self.__job_flag = True
+        Thread(target=self.__send_analytic_job, daemon=True).start()
+
+    def stop(self):
+        self.__job_flag = False
+        self.__flush_event.set()  # unblock any active sleep
+
+    def flush(self):
+        """Immediately flush all pending analytics data.
+
+        Safe to call concurrently with the background job — ``__flush_lock``
+        ensures only one drain/flush pipeline runs at a time.
+        """
+        with self.__flush_lock:
+            self.__drain_chunks()
+            self.__flush_remainder()

ibm_appconfiguration_python_sdk-0.5.0/ibm_appconfiguration/configurations/internal/utils/analytics_record.py

@@ -0,0 +1,156 @@
+# Copyright 2021 IBM All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module provides methods that perform analytics related operations.
+"""
+from copy import deepcopy
+from enum import Enum
+from typing import Any
+
+from ibm_appconfiguration.configurations.internal.common.config_constants import DELIMITER
+
+
+class EventType(Enum):
+    GUARDED_METRIC = 1
+    GUARDED_EVALUATION = 2
+
+
+class AnalyticsRecord:
+    """In-memory store for analytics usages.
+
+    NOT thread-safe on its own. All concurrent access must be serialised
+    by the caller (Analytics) holding its own lock before calling any method.
+    """
+
+    def __init__(self):
+        self._usages: list[dict[str, Any]] = []
+        self._history_map: dict[str, int] = {}
+
+    @staticmethod
+    def _build_key(*args) -> str:
+        return DELIMITER.join(args)
+
+    @staticmethod
+    def _build_metric_key(metric: dict[str, Any], metric_type: EventType) -> str:
+        match metric_type:
+            case EventType.GUARDED_EVALUATION:
+                return AnalyticsRecord._build_key(
+                    metric["rollout_id"],
+                    metric["entity_id"],
+                    metric["value_served"],
+                )
+            case EventType.GUARDED_METRIC:
+                return AnalyticsRecord._build_key(
+                    metric["rollout_id"],
+                    metric["entity_id"],
+                    metric["value_served"],
+                    metric["event_key"],
+                )
+            case _:
+                raise ValueError(f"Unsupported metric type: {metric_type}")
+
+    def _insert_or_create_record(self, index: int, metric: dict[str, Any], metric_type: EventType):
+        # Attach the metadata block.
+        match metric_type:
+            case EventType.GUARDED_EVALUATION:
+                metric["metadata"] = {"feature": "guarded", "event_type": "evaluation"}
+            case EventType.GUARDED_METRIC:
+                metric["metadata"] = {"feature": "guarded", "event_type": "metric"}
+
+        if index == -1:
+            # New entry.
+            if metric_type == EventType.GUARDED_METRIC:
+                metric["count"] = 1
+            self._usages.append(metric)
+            self._history_map[self._build_metric_key(metric, metric_type)] = len(self._usages) - 1
+            return
+
+        # Existing entry — only metric types are aggregated (count + latest timestamp).
+        if metric_type == EventType.GUARDED_METRIC:
+            self._usages[index]["count"] += 1
+            self._usages[index]["timestamp"] = max(self._usages[index]["timestamp"], metric["timestamp"])
+
+    def add(self, metric: dict[str, Any], metric_type: EventType):
+        key = self._build_metric_key(metric, metric_type)
+        self._insert_or_create_record(self._history_map.get(key, -1), metric, metric_type)
+
+    def get_request_body(self, environment_id: str, collection_id: str) -> dict[str, Any]:
+        usages = []
+        for usage in self._usages:
+            usage_copy = deepcopy(usage)
+            usage_copy.pop('event_key', None)
+            usages.append(usage_copy)
+        return {
+            "environment_id": environment_id,
+            "collection_id": collection_id,
+            "usages": usages,
+        }
+
+    def __len__(self) -> int:
+        return len(self._usages)
+
+    def get_record_length(self) -> int:
+        return len(self._usages)
+
+    def exceeds_limit(self, limit: int) -> bool:
+        return len(self._usages) >= limit
+
+    def split_head(self, n: int) -> 'AnalyticsRecord':
+        """Remove and return the first *n* usages as a new AnalyticsRecord.
+
+        The caller must hold the outer Analytics lock before calling this.
+        Insertion order is preserved — oldest entries are returned first.
+        """
+        head = AnalyticsRecord()
+        head._usages = self._usages[:n]
+        for i, usage in enumerate(head._usages):
+            metric_type = AnalyticsRecord._get_metric_type(usage)
+            key = AnalyticsRecord._build_metric_key(usage, metric_type)
+            head._history_map[key] = i
+
+        self._usages = self._usages[n:]
+        self._history_map = {}
+        for i, usage in enumerate(self._usages):
+            metric_type = AnalyticsRecord._get_metric_type(usage)
+            key = AnalyticsRecord._build_metric_key(usage, metric_type)
+            self._history_map[key] = i
+
+        return head
+
+    @staticmethod
+    def _get_metric_type(metric: dict[str, Any]) -> EventType:
+        feature = metric["metadata"]["feature"]
+        event_type = metric["metadata"]["event_type"]
+        return EventType.GUARDED_EVALUATION if event_type == "evaluation" else EventType.GUARDED_METRIC
+
+    def merge(self, other: 'AnalyticsRecord'):
+        """Merge all usages from *other* into self.
+
+        The caller must hold the outer Analytics lock before calling this.
+        """
+        if not isinstance(other, AnalyticsRecord):
+            return
+        for usage in other._usages:
+            metric_type = AnalyticsRecord._get_metric_type(usage)
+            key = self._build_metric_key(usage, metric_type)
+            index = self._history_map.get(key, -1)
+            if index == -1:
+                self._usages.append(usage)
+                self._history_map[key] = len(self._usages) - 1
+            elif metric_type == EventType.GUARDED_METRIC:
+                self._usages[index]["count"] += usage["count"]
+                self._usages[index]["timestamp"] = max(
+                    self._usages[index]["timestamp"], usage["timestamp"]
+                )

{ibm_appconfiguration_python_sdk-0.4.4 → ibm_appconfiguration_python_sdk-0.5.0}/ibm_appconfiguration/configurations/internal/utils/metering.py

@@ -16,7 +16,7 @@
 This module provides methods that perform metering and usage related operations.
 """
 from threading import Lock, Timer
-from datetime import datetime
+from datetime import datetime, timezone
 from .api_manager import APIManager
 from .logger import Logger
 from ..common import config_messages, config_constants
@@ -80,7 +80,7 @@ class Metering:
 
         self.__lock.acquire()
         try:
-            time = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+            time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
             feature_json = {
                 'count': 1,
                 'evaluation_time': time