removed old telemetry

CHANGES.txt

@@ -1,3 +1,6 @@
+9.2.0 (Dec XX, 2021)
+- 
+
 9.1.0 (Jul 15, 2021)
 - Added Cache-Control header for on-demand requests to sdk-server.
 - Updated the synchronization flow to be more reliable in the event of an edge case generating delay in cache purge propagation, keeping the SDK cache properly synced.

splitio/client/client.py

@@ -329,7 +329,7 @@ def _build_impression(  # pylint: disable=too-many-arguments
 
     def _record_stats(self, impressions, start, operation):
         """
-        Record impressions and metrics.
+        Record impressions.
 
         :param impressions: Generated impressions
         :type impressions: list[tuple[splitio.models.impression.Impression, dict]]

splitio/client/factory.py

@@ -15,26 +15,24 @@
 
 # Storage
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
-    InMemoryImpressionStorage, InMemoryEventStorage, InMemoryTelemetryStorage
+    InMemoryImpressionStorage, InMemoryEventStorage
 from splitio.storage.adapters import redis
 from splitio.storage.redis import RedisSplitStorage, RedisSegmentStorage, RedisImpressionsStorage, \
-    RedisEventsStorage, RedisTelemetryStorage
+    RedisEventsStorage
 
 # APIs
 from splitio.api.client import HttpClient
 from splitio.api.splits import SplitsAPI
 from splitio.api.segments import SegmentsAPI
 from splitio.api.impressions import ImpressionsAPI
 from splitio.api.events import EventsAPI
-from splitio.api.telemetry import TelemetryAPI
 from splitio.api.auth import AuthAPI
 
 # Tasks
 from splitio.tasks.split_sync import SplitSynchronizationTask
 from splitio.tasks.segment_sync import SegmentSynchronizationTask
 from splitio.tasks.impressions_sync import ImpressionsSyncTask, ImpressionsCountSyncTask
 from splitio.tasks.events_sync import EventsSyncTask
-from splitio.tasks.telemetry_sync import TelemetrySynchronizationTask
 
 # Synchronizer
 from splitio.sync.synchronizer import SplitTasks, SplitSynchronizers, Synchronizer, \
@@ -44,14 +42,12 @@
 from splitio.sync.segment import SegmentSynchronizer
 from splitio.sync.impression import ImpressionSynchronizer, ImpressionsCountSynchronizer
 from splitio.sync.event import EventSynchronizer
-from splitio.sync.telemetry import TelemetrySynchronizer
 
 # Recorder
 from splitio.recorder.recorder import StandardRecorder, PipelinedRecorder
 
 # Localhost stuff
-from splitio.client.localhost import LocalhostEventsStorage, LocalhostImpressionsStorage, \
-    LocalhostTelemetryStorage
+from splitio.client.localhost import LocalhostEventsStorage, LocalhostImpressionsStorage
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -259,7 +255,6 @@ def resume(self):
         sdk_ready_flag = threading.Event()
         self._sdk_internal_ready_flag = sdk_ready_flag
         self._sync_manager._ready_flag = sdk_ready_flag
-        self._get_storage('telemetry').clear()
         self._get_storage('impressions').clear()
         self._get_storage('events').clear()
         initialization_thread = threading.Thread(
@@ -306,7 +301,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         'segments': SegmentsAPI(http_client, api_key, sdk_metadata),
         'impressions': ImpressionsAPI(http_client, api_key, sdk_metadata, cfg['impressionsMode']),
         'events': EventsAPI(http_client, api_key, sdk_metadata),
-        'telemetry': TelemetryAPI(http_client, api_key, sdk_metadata)
     }
 
     if not input_validator.validate_apikey_type(apis['segments']):
@@ -317,7 +311,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         'segments': InMemorySegmentStorage(),
         'impressions': InMemoryImpressionStorage(cfg['impressionsQueueSize']),
         'events': InMemoryEventStorage(cfg['eventsQueueSize']),
-        'telemetry': InMemoryTelemetryStorage()
     }
 
     imp_manager = ImpressionsManager(
@@ -331,7 +324,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         ImpressionSynchronizer(apis['impressions'], storages['impressions'],
                                cfg['impressionsBulkSize']),
         EventSynchronizer(apis['events'], storages['events'], cfg['eventsBulkSize']),
-        TelemetrySynchronizer(apis['telemetry'], storages['telemetry']),
         ImpressionsCountSynchronizer(apis['impressions'], imp_manager),
     )
 
@@ -349,10 +341,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
             cfg['impressionsRefreshRate'],
         ),
         EventsSyncTask(synchronizers.events_sync.synchronize_events, cfg['eventsPushRate']),
-        TelemetrySynchronizationTask(
-            synchronizers.telemetry_sync.synchronize_telemetry,
-            cfg['metricsRefreshRate'],
-        ),
         ImpressionsCountSyncTask(synchronizers.impressions_count_sync.synchronize_counters)
     )
 
@@ -369,7 +357,6 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
 
     recorder = StandardRecorder(
         imp_manager,
-        storages['telemetry'],
         storages['events'],
         storages['impressions'],
     )
@@ -399,13 +386,11 @@ def _build_redis_factory(api_key, cfg):
         'segments': RedisSegmentStorage(redis_adapter),
         'impressions': RedisImpressionsStorage(redis_adapter, sdk_metadata),
         'events': RedisEventsStorage(redis_adapter, sdk_metadata),
-        'telemetry': RedisTelemetryStorage(redis_adapter, sdk_metadata)
     }
     recorder = PipelinedRecorder(
         redis_adapter.pipeline,
         ImpressionsManager(cfg['impressionsMode'], False,
                            _wrap_impression_listener(cfg['impressionListener'], sdk_metadata)),
-        storages['telemetry'],
         storages['events'],
         storages['impressions'],
     )
@@ -424,19 +409,18 @@ def _build_localhost_factory(cfg):
         'segments': InMemorySegmentStorage(),  # not used, just to avoid possible future errors.
         'impressions': LocalhostImpressionsStorage(),
         'events': LocalhostEventsStorage(),
-        'telemetry': LocalhostTelemetryStorage()
     }
 
     synchronizers = SplitSynchronizers(
         LocalSplitSynchronizer(cfg['splitFile'], storages['splits']),
-        None, None, None, None, None,
+        None, None, None, None,
     )
 
     tasks = SplitTasks(
         SplitSynchronizationTask(
             synchronizers.split_sync.synchronize_splits,
             cfg['featuresRefreshRate'],
-        ), None, None, None, None, None,
+        ), None, None, None, None,
     )
 
     sdk_metadata = util.get_metadata(cfg)
@@ -446,7 +430,6 @@ def _build_localhost_factory(cfg):
     manager.start()
     recorder = StandardRecorder(
         ImpressionsManager(cfg['impressionsMode'], True, None),
-        storages['telemetry'],
         storages['events'],
         storages['impressions'],
     )

splitio/client/localhost.py

@@ -2,7 +2,7 @@
 import logging
 import re
 
-from splitio.storage import ImpressionStorage, EventStorage, TelemetryStorage
+from splitio.storage import ImpressionStorage, EventStorage
 
 _LEGACY_COMMENT_LINE_RE = re.compile(r'^#.*$')
 _LEGACY_DEFINITION_LINE_RE = re.compile(r'^(?<![^#])(?P<feature>[\w_-]+)\s+(?P<treatment>[\w_-]+)$')
@@ -41,35 +41,3 @@ def pop_many(self, *_, **__):  # pylint: disable=arguments-differ
     def clear(self, *_, **__):  # pylint: disable=arguments-differ
         """Accept any arguments and do nothing."""
         pass
-
-
-class LocalhostTelemetryStorage(TelemetryStorage):
-    """Impression storage that doesn't cache anything."""
-
-    def inc_latency(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass
-
-    def inc_counter(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass
-
-    def put_gauge(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass
-
-    def pop_latencies(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass
-
-    def pop_counters(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass
-
-    def pop_gauges(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass
-
-    def clear(self, *_, **__):  # pylint: disable=arguments-differ
-        """Accept any arguments and do nothing."""
-        pass