Merge pull request #16 from statsig-io/0-16-9

v0.16.9 - Expose group_name, init diagnostics, top-level flush, & more

Author: kenny-statsig

.github/workflows/kong.yml

@@ -1,5 +1,11 @@
 name: KONG
 
+env:
+  test_api_key: ${{ secrets.KONG_SERVER_SDK_KEY }}
+  test_client_key: ${{ secrets. KONG_CLIENT_SDK_KEY }}
+  repo_pat: ${{ secrets.KONG_FINE_GRAINED_REPO_PAT }}
+  FORCE_COLOR: true
+
 on:
   workflow_dispatch:
   schedule:
@@ -14,26 +20,22 @@ jobs:
     timeout-minutes: 5
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-python@v2
-        with:
-          python-version: "3.8"
-
       - name: Get KONG
         run: |
-          git clone https://${{ secrets.KONG_REPO_PAT }}@github.com/statsig-io/kong.git
+          git clone https://oauth2:$repo_pat@github.com/statsig-io/kong.git .
 
-      - name: Setup Python Server
-        run: |
-          cd kong/bridges/python-server
-          BRANCH="${GITHUB_HEAD_REF:-main}"; pip install statsig git+https://${repo_pat}@github.com/$GITHUB_REPOSITORY.git@$BRANCH
-        env:
-          repo_pat: ${{ secrets.KONG_REPO_PAT }}
+      - uses: actions/setup-node@v1
+        with:
+          node-version: "16.x"
+
+      - name: Install Deps
+        run: npm install
+
+      - name: Setup Python SDK
+        run: npm run kong -- setup python -v
+
+      - name: Build Bridge
+        run: npm run kong -- build python -v
 
       - name: Run Tests
-        run: |
-          cd kong
-          npm install
-          FORCE_COLOR=true npm run kong -- test python -w -r
-        env:
-          test_api_key: ${{ secrets.KONG_SERVER_SDK_KEY }}
-          test_client_key: ${{ secrets.KONG_CLIENT_SDK_KEY }}
+        run: npm run kong -- test python -v -r

statsig/diagnostics.py

@@ -0,0 +1,37 @@
+import time
+
+
+class _Diagnostics:
+    def __init__(self, context):
+        self.context = context
+        self.markers = []
+
+    def mark(self, key, action, step=None, value=None):
+        marker = Marker(key, action, step, value)
+        self.markers.append(marker)
+
+    def serialize(self) -> object:
+        return {
+            "markers": [marker.serialize() for marker in self.markers],
+            "context": self.context
+        }
+
+
+class Marker:
+    def __init__(self, key, action, step, value):
+        if key is None:
+            key = ""
+        self.key = key
+        self.action = action
+        self.step = step
+        self.value = value
+        self.timestamp = round(time.time()*1000)
+
+    def serialize(self) -> object:
+        return {
+            "key": self.key,
+            "step": self.step,
+            "action": self.action,
+            "value": self.value,
+            "timestamp": self.timestamp,
+        }

statsig/dynamic_config.py

@@ -1,5 +1,5 @@
 class DynamicConfig:
-    def __init__(self, data, name, rule):
+    def __init__(self, data, name, rule, group_name=None):
         if data is None:
             data = {}
         self.value = data
@@ -9,6 +9,7 @@ def __init__(self, data, name, rule):
         if rule is None:
             rule = ""
         self.rule_id = rule
+        self.group_name = group_name
 
     def get(self, key, default=None):
         """Returns the value of the config at the given key

statsig/evaluator.py

@@ -24,7 +24,8 @@ def __init__(self,
                  allocated_experiment=None,
                  explicit_parameters=None,
                  is_experiment_group=False,
-                 evaluation_details=None):
+                 evaluation_details=None,
+                 group_name=None):
         if fetch_from_server is None:
             fetch_from_server = False
         self.fetch_from_server = fetch_from_server
@@ -46,8 +47,8 @@ def __init__(self,
         self.allocated_experiment = allocated_experiment
         self.explicit_parameters = explicit_parameters
         self.is_experiment_group = is_experiment_group is True
-
         self.evaluation_details = evaluation_details
+        self.group_name = group_name
 
 
 class _Evaluator:
@@ -225,7 +226,8 @@ def __evaluate(self, user, config):
                     result.rule_id,
                     exposures,
                     is_experiment_group=result.is_experiment_group,
-                    evaluation_details=evaluation_details
+                    evaluation_details=evaluation_details,
+                    group_name=result.group_name
                 )
 
         return _ConfigEvaluation(False, False, default_value, "default", exposures,
@@ -247,7 +249,8 @@ def __evaluate_rule(self, user, rule):
         rule_id = rule.get("id", "")
 
         return _ConfigEvaluation(False, eval_result, return_value, rule_id, exposures,
-                                 is_experiment_group=rule.get("isExperimentGroup", False))
+                                 is_experiment_group=rule.get("isExperimentGroup", False),
+                                 group_name=rule.get("groupName", None))
 
     def __evaluate_delegate(self, user, rule, exposures):
         config_delegate = rule.get('configDelegate', None)

statsig/spec_store.py

@@ -9,13 +9,15 @@
 from .statsig_network import _StatsigNetwork
 from .statsig_options import StatsigOptions
 from .thread_util import spawn_background_thread, THREAD_JOIN_TIMEOUT
+from .diagnostics import _Diagnostics
 from .utils import logger
 
 RULESETS_SYNC_INTERVAL = 10
 IDLISTS_SYNC_INTERVAL = 60
 STORAGE_ADAPTER_KEY = "statsig.cache"
 SYNC_OUTDATED_MAX_S = 120
 
+
 def _is_specs_json_valid(specs_json):
     if specs_json is None or specs_json.get("time") is None:
         return False
@@ -30,7 +32,8 @@ class _SpecStore:
     _background_download_id_lists: Optional[threading.Thread]
 
     def __init__(self, network: _StatsigNetwork, options: StatsigOptions, statsig_metadata: dict,
-                 error_boundary: _StatsigErrorBoundary, shutdown_event: threading.Event):
+                 error_boundary: _StatsigErrorBoundary, shutdown_event: threading.Event,
+                 init_diagnostics: _Diagnostics):
         self.last_update_time = 0
         self.initial_update_time = 0
         self.init_reason = EvaluationReason.uninitialized
@@ -44,6 +47,7 @@ def __init__(self, network: _StatsigNetwork, options: StatsigOptions, statsig_me
         self._background_download_configs = None
         self._background_download_id_lists = None
         self._sync_failure_count = 0
+        self._init_diagnostics = init_diagnostics
 
         self._configs = {}
         self._gates = {}
@@ -119,14 +123,15 @@ def _initialize_specs(self):
             if self._options.bootstrap_values is not None:
                 logger.warning(
                     "data_store gets priority over bootstrap_values. bootstrap_values will be ignored")
-
             self._load_config_specs_from_storage_adapter()
             if self.last_update_time == 0:
                 self._log_process("Retrying with network...")
                 self._download_config_specs()
 
         elif self._options.bootstrap_values is not None:
+            self._init_diagnostics.mark("bootstrap", "start", "load")
             self._bootstrap_config_specs()
+            self._init_diagnostics.mark("bootstrap", "end", "load")
 
         else:
             self._download_config_specs()
@@ -202,22 +207,28 @@ def _download_config_specs(self):
             log_on_exception = True
             self._sync_failure_count = 0
 
-        specs = self._network.post_request("download_config_specs", {
-            "statsigMetadata": self._statsig_metadata,
-            "sinceTime": self.last_update_time,
-        }, log_on_exception)
+        try:
+            specs = self._network.post_request("download_config_specs", {
+                "statsigMetadata": self._statsig_metadata,
+                "sinceTime": self.last_update_time,
+            }, log_on_exception, self._init_diagnostics)
+        except Exception as e:
+            raise e
 
         if specs is None:
             self._sync_failure_count += 1
             return
 
+        self._init_diagnostics.mark("download_config_specs", "start", "process")
         if not _is_specs_json_valid(specs):
+            self._init_diagnostics.mark("download_config_specs", "end", "process", False)
             return
 
         self._log_process("Done loading specs")
         if self._process_specs(specs):
             self._save_to_storage_adapter(specs)
             self.init_reason = EvaluationReason.network
+        self._init_diagnostics.mark("download_config_specs", "end", "process", self.init_reason == EvaluationReason.network)
 
     def _save_to_storage_adapter(self, specs):
         if not _is_specs_json_valid(specs):
@@ -232,6 +243,7 @@ def _save_to_storage_adapter(self, specs):
         self._options.data_store.set(STORAGE_ADAPTER_KEY, json.dumps(specs))
 
     def _load_config_specs_from_storage_adapter(self):
+        self._init_diagnostics.mark("bootstrap", "start", "load")
         self._log_process("Loading specs from adapter")
         if self._options.data_store is None:
             return
@@ -254,6 +266,7 @@ def _load_config_specs_from_storage_adapter(self):
         self._log_process("Done loading specs")
         if self._process_specs(cache):
             self.init_reason = EvaluationReason.data_adapter
+        self._init_diagnostics.mark("bootstrap", "end", "load")
 
     def _spawn_bg_download_id_lists(self):
         self._background_download_id_lists = spawn_background_thread(self._sync, (
@@ -264,9 +277,11 @@ def _download_id_lists(self):
         try:
             server_id_lists = self._network.post_request("get_id_lists", {
                 "statsigMetadata": self._statsig_metadata,
-            })
+            }, False, self._init_diagnostics)
+
             if server_id_lists is None:
                 return
+            self._init_diagnostics.mark("get_id_lists", "start", "process")
 
             local_id_lists = self._id_lists
             workers = []
@@ -321,7 +336,10 @@ def _download_id_lists(self):
             # remove any list that has been deleted
             for list_name in deleted_lists:
                 local_id_lists.pop(list_name, None)
+            self._init_diagnostics.mark("get_id_lists", "end", "process", True)
+
         except Exception as e:
+            self._init_diagnostics.mark("get_id_lists", "end", "process", False)
             self._error_boundary.log_exception(e)
 
     def _download_single_id_list(

statsig/statsig.py

@@ -256,6 +256,14 @@ def evaluate_all(user: StatsigUser):
     """
     return __instance.evaluate_all(user)
 
+def flush():
+    """
+    Flushes any queued event logs
+    NOTE: the sdk flushes events in the background every minute or 500 events
+    For long running webservers, let the sdk manage the background flush
+    when using the sdk in a script or scenario where you need to flush logs, use this method
+    """
+    __instance.flush()
 
 def shutdown():
     """

statsig/statsig_event.py

@@ -22,8 +22,6 @@ class StatsigEvent:
     _time: int = field(default_factory=lambda: round(time.time() * 1000))
 
     def __post_init__(self):
-        if self.user is None or not isinstance(self.user, StatsigUser):
-            raise StatsigValueError('StatsigEvent.user must be set')
         if self.event_name is None or self.event_name == "":
             raise StatsigValueError(
                 'StatsigEvent.event_name must be a valid str')