wingify-fme-python-sdk 1.61.0__tar.gz → 1.62.0__tar.gz

{wingify_fme_python_sdk-1.61.0/wingify_fme_python_sdk.egg-info → wingify_fme_python_sdk-1.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wingify-fme-python-sdk
-Version: 1.61.0
+Version: 1.62.0
 Summary: Wingify Feature Management and Experimentation SDK for Python
 Home-page: https://github.com/wingify/vwo-fme-python-sdk
 Author: Wingify

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0}/setup.py

@@ -143,7 +143,7 @@ class PostDevelopCommand(develop):
 
 setup(
     name=_brand["name"],
-    version="1.61.0",
+    version="1.62.0",
     description=_brand["description"],
     long_description=long_description,
     long_description_content_type="text/markdown",

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0}/wingify/constants/Constants.py

@@ -17,7 +17,7 @@ class Constants:
     # TODO: read from setup.py
     sdk_meta = {
         "name": "vwo-fme-python-sdk",
-        "version": "1.61.0",
+        "version": "1.62.0",
     }
 
     SDK_VERSION = sdk_meta["version"]
@@ -87,3 +87,6 @@ class Constants:
 
     VARIATION_IS_PART_OF_HOLDOUT = 1
     VARIATION_NOT_PART_OF_HOLDOUT = 2
+
+    INTERNAL_EVENTS_DEFAULT_SAMPLING_PERCENT_SERVER = 10.0
+    INTERNAL_EVENTS_DEFAULT_ALWAYS_APPLY_SAMPLING = False

wingify_fme_python_sdk-1.62.0/wingify/constants/sampled_debug_error_template_keys.py

@@ -0,0 +1,34 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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.
+
+class SampledDebugErrorTemplateKeys:
+    """
+    Debug error template keys (`msg_t`) that are subject to sampling.
+    Keys not listed here always send and bypass sampling.
+    """
+    SAMPLED_KEYS = {
+        "EVENT_NOT_FOUND",
+        "FEATURE_NOT_FOUND",
+        "FEATURE_NOT_FOUND_WITH_ID"
+    }
+
+    @staticmethod
+    def contains(message_template_key: str) -> bool:
+        """
+        Checks whether a debug error template key should be sampled before sending.
+
+        :param message_template_key: The `msg_t` value from the debug event
+        :return: `True` if the key is in the sampled set; `False` otherwise
+        """
+        return message_template_key is not None and message_template_key in SampledDebugErrorTemplateKeys.SAMPLED_KEYS

wingify_fme_python_sdk-1.62.0/wingify/models/settings/internal_event_sampling_settings_model.py

@@ -0,0 +1,53 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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.
+
+from typing import Dict, Any, Optional
+
+class PlatformSamplingRates:
+    """
+    Holds the sampling percentage for a specific platform (e.g., server).
+    Maps to the per-platform object inside `sampling.usage` or `sampling.debug`.
+    """
+    def __init__(self, data: Dict[str, Any]):
+        self._server = data.get("server")
+
+    def get_server(self) -> Optional[float]:
+        return self._server
+
+class EventCategorySamplingRates:
+    """
+    Groups sampling rates by event category: `usage` and `debug`.
+    Maps to the top-level `sampling` object in the DaCDN settings.
+    """
+    def __init__(self, data: Dict[str, Any]):
+        self._usage = PlatformSamplingRates(data.get("usage", {})) if data.get("usage") else None
+        self._debug = PlatformSamplingRates(data.get("debug", {})) if data.get("debug") else None
+
+    def get_usage(self) -> Optional[PlatformSamplingRates]:
+        return self._usage
+
+    def get_debug(self) -> Optional[PlatformSamplingRates]:
+        return self._debug
+
+class AlwaysApplySampling:
+    """
+    Controls whether sampling is enforced before sending an event.
+    Maps to `alwaysApplySampling` in DaCDN settings.
+    When `server` is False (the default), usage-stats and sampled debug events bypass sampling and are always sent.
+    """
+    def __init__(self, data: Dict[str, Any]):
+        self._server = data.get("server")
+
+    def get_server(self) -> Optional[bool]:
+        return self._server

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0}/wingify/models/settings/settings_model.py

@@ -13,13 +13,14 @@
 # limitations under the License.
 
 
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Any
 from ..campaign.campaign_model import CampaignModel
 from ..campaign.feature_model import FeatureModel
 from ...utils.model_utils import _parse_campaign, _parse_feature
 import json
 from ...constants.Constants import Constants
 from ..campaign.holdout_model import HoldoutModel
+from .internal_event_sampling_settings_model import AlwaysApplySampling, EventCategorySamplingRates
 
 
 class SettingsModel:
@@ -37,6 +38,10 @@ class SettingsModel:
         self._is_web_connectivity_enabled = data.get("isWebConnectivityEnabled", True)
         self._holdouts = [HoldoutModel(h) for h in data.get("holdouts", [])]
         self._is_tracking_usage_enabled = data.get("isMAU", False)
+        self._sdk_meta_info = data.get("sdkMetaInfo", {})
+        self._usage_stats_account_id = data.get("usageStatsAccountId", None)
+        self._always_apply_sampling = AlwaysApplySampling(data.get("alwaysApplySampling", {})) if data.get("alwaysApplySampling") is not None else None
+        self._sampling = EventCategorySamplingRates(data.get("sampling", {})) if data.get("sampling") is not None else None
 
     # Getter methods for accessing private attributes
     def get_features(self) -> List[FeatureModel]:
@@ -107,4 +112,16 @@ class SettingsModel:
         return self._is_tracking_usage_enabled
 
     def set_is_tracking_usage_enabled(self, value: bool):
-        self._is_tracking_usage_enabled = value
+        self._is_tracking_usage_enabled = value
+
+    def get_sdk_meta_info(self) -> Dict[str, Any]:
+        return self._sdk_meta_info
+
+    def get_usage_stats_account_id(self) -> Optional[int]:
+        return self._usage_stats_account_id
+
+    def get_always_apply_sampling(self) -> Optional[AlwaysApplySampling]:
+        return self._always_apply_sampling
+
+    def get_sampling(self) -> Optional[EventCategorySamplingRates]:
+        return self._sampling

wingify_fme_python_sdk-1.62.0/wingify/services/internal_events_sampling_service.py

@@ -0,0 +1,62 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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.
+
+import random
+from typing import Callable, Optional
+from ..models.settings.settings_model import SettingsModel
+from ..utils.internal_events_sampling_util import (
+    should_apply_sampling,
+    get_usage_stats_sampling_percent,
+    get_debug_event_sampling_percent,
+    passes_sampling_percent,
+)
+
+class InternalEventsSamplingService:
+    """
+    Applies sampling rules for internal SDK events:
+    `vwo_sdkUsageStats` and sampled `vwo_sdkDebug`.
+    """
+
+    def __init__(self, random_value_provider: Optional[Callable[[], float]] = None):
+        """
+        Creates a sampling service.
+        :param random_value_provider: Optional supplier returning a value in [0, 1) for sampling checks; overridable in tests.
+        """
+        self._random_value_provider = random_value_provider if random_value_provider is not None else random.random
+
+    def should_send_usage_stats_event(self, settings: Optional[SettingsModel]) -> bool:
+        """
+        Determines whether the usage-stats event should be sent.
+        On server, always sends unless `alwaysApplySampling.server` is enabled.
+        :param settings: Parsed settings from the server
+        :return: `True` when the usage-stats event should be sent
+        """
+        if not should_apply_sampling(settings):
+            return True
+        
+        usage_stats_sampling_percent = get_usage_stats_sampling_percent(settings)
+        return passes_sampling_percent(usage_stats_sampling_percent, self._random_value_provider())
+
+    def should_send_sampled_debug_event(self, settings: Optional[SettingsModel]) -> bool:
+        """
+        Determines whether a sampled debug event should be sent.
+        Only called for `msg_t` keys in the sampled set; always-send keys bypass this.
+        :param settings: Parsed settings from the server
+        :return: `True` when the sampled debug event should be sent
+        """
+        if not should_apply_sampling(settings):
+            return True
+        
+        debug_sampling_percent = get_debug_event_sampling_percent(settings)
+        return passes_sampling_percent(debug_sampling_percent, self._random_value_provider())

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0}/wingify/utils/debugger_service_util.py

@@ -30,6 +30,22 @@ def send_debug_event_to_vwo(debug_event_props: Dict[str, Any]):
             get_debugger_event_payload,
             send_event,
         )
+        from ..utils.internal_events_sampling_util import is_sampled_debug_error_template_key
+        from ..services.internal_events_sampling_service import InternalEventsSamplingService
+        from ..wingify import Wingify
+
+        # Sampled keys: apply sampling only when alwaysApplySampling.server is true; others are ALWAYS_SEND
+        msg_t = debug_event_props.get("msg_t")
+        is_sampled_debug_event = isinstance(msg_t, str) and is_sampled_debug_error_template_key(msg_t)
+
+        instance = Wingify.getInstance()
+        settings = getattr(instance, '_settings', None) if instance else None
+        # if the event is present in the sampled debug events keys list, then apply sampling
+        if is_sampled_debug_event:
+            sampling_service = InternalEventsSamplingService()
+            if not sampling_service.should_send_sampled_debug_event(settings):
+                return
+
         # Create the query parameters
         properties = get_events_base_properties(EventEnum.DEBUGGER_EVENT.value)
         # Create the payload with required fields

wingify_fme_python_sdk-1.62.0/wingify/utils/internal_events_sampling_util.py

@@ -0,0 +1,106 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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.
+
+import math
+from typing import Optional
+from ..constants.Constants import Constants
+from ..constants.sampled_debug_error_template_keys import SampledDebugErrorTemplateKeys
+from ..models.settings.settings_model import SettingsModel
+from ..models.settings.internal_event_sampling_settings_model import PlatformSamplingRates
+
+def get_default_sampling_percent() -> float:
+    """
+    Returns the default server sampling percentage when settings omit the value.
+    :return: Default sampling percentage (10.0)
+    """
+    return Constants.INTERNAL_EVENTS_DEFAULT_SAMPLING_PERCENT_SERVER
+
+def normalize_sampling_percent(sampling_value: Optional[float]) -> float:
+    """
+    Normalizes a sampling value to a valid percentage in the range [0, 100].
+    Falls back to the server default when the value is missing or invalid.
+    :param sampling_value: Raw value from settings
+    :return: Valid sampling percentage between 0 and 100
+    """
+    if sampling_value is not None and 0 <= sampling_value <= 100:
+        return float(sampling_value)
+    
+    return get_default_sampling_percent()
+
+def get_runtime_sampling_percent(runtime_sampling_config: Optional[PlatformSamplingRates]) -> float:
+    """
+    Reads the server sampling percentage from a runtime sampling config object.
+    :param runtime_sampling_config: Nested config (e.g. `sampling.usage`)
+    :return: Sampling percentage for the server runtime
+    """
+    if runtime_sampling_config is None:
+        return get_default_sampling_percent()
+    
+    return normalize_sampling_percent(runtime_sampling_config.get_server())
+
+def get_usage_stats_sampling_percent(settings: Optional[SettingsModel]) -> float:
+    """
+    Reads the usage-stats sampling percentage for the server runtime from settings.
+    :param settings: Parsed settings from the server
+    :return: Configured usage-stats sampling percentage (0-100)
+    """
+    sampling = settings.get_sampling() if settings else None
+    usage_sampling = sampling.get_usage() if sampling else None
+    return get_runtime_sampling_percent(usage_sampling)
+
+def get_debug_event_sampling_percent(settings: Optional[SettingsModel]) -> float:
+    """
+    Reads the debug-event sampling percentage for the server runtime from settings.
+    :param settings: Parsed settings from the server
+    :return: Configured debug sampling percentage (0-100)
+    """
+    sampling = settings.get_sampling() if settings else None
+    debug_sampling = sampling.get_debug() if sampling else None
+    return get_runtime_sampling_percent(debug_sampling)
+
+def should_apply_sampling(settings: Optional[SettingsModel]) -> bool:
+    """
+    Determines whether sampling should be evaluated before send.
+    Controlled by `alwaysApplySampling.server`; defaults to `False`.
+    When `False`, usage-stats and sampled debug events are always sent.
+    :param settings: Parsed settings from the server
+    :return: `True` when a sampling check is required before sending
+    """
+    if settings is None:
+        return Constants.INTERNAL_EVENTS_DEFAULT_ALWAYS_APPLY_SAMPLING
+
+    always_apply_sampling = settings.get_always_apply_sampling()
+    if always_apply_sampling is None or always_apply_sampling.get_server() is None:
+        return Constants.INTERNAL_EVENTS_DEFAULT_ALWAYS_APPLY_SAMPLING
+
+    return always_apply_sampling.get_server()
+
+def passes_sampling_percent(sampling_percent: float, random_value: float) -> bool:
+    """
+    Evaluates whether an event qualifies under the configured sampling percentage.
+    :param sampling_percent: Configured sampling percentage (0-100)
+    :param random_value: Random value in the range [0, 1)
+    :return: `True` when the random draw falls within the sampling threshold
+    """
+    # Map random [0,1) to integer percent bucket [0,100]
+    normalized_random_percent = int(math.floor(random_value * 101))
+    return normalized_random_percent <= sampling_percent
+
+def is_sampled_debug_error_template_key(message_template_key: str) -> bool:
+    """
+    Checks whether a debug error template key is in the sampled set.
+    :param message_template_key: The `msg_t` value from the debug event
+    :return: `True` when the key requires sampling before send
+    """
+    return SampledDebugErrorTemplateKeys.contains(message_template_key)

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0}/wingify/wingify.py

@@ -25,6 +25,7 @@ from wingify.utils.brand_context import set_is_via_vwo
 from wingify.utils.brand_util import get_brand
 from wingify.utils.log_message_util import refresh_log_messages
 from wingify.packages.logger.core.log_manager import LogManager
+from wingify.services.internal_events_sampling_service import InternalEventsSamplingService
 
 
 class Wingify:
@@ -103,22 +104,22 @@ def init(options: Dict[str, Any]) -> Optional["WingifyClient"]:
         sdk_init_time = int((time.time() * 1000) - start_time_for_init)
 
         was_initialized = False
-        if instance.original_settings is not None:
-            was_initialized = instance.original_settings.get("sdkMetaInfo", {}).get(
-                "wasInitializedEarlier"
-            )
+        if getattr(instance, '_settings', None) is not None:
+            sdk_meta_info = instance._settings.get_sdk_meta_info()
+            if sdk_meta_info:
+                was_initialized = sdk_meta_info.get("wasInitializedEarlier", False)
 
         if instance.is_settings_valid_on_init and not was_initialized:
             send_sdk_init_event(instance.settings_fetch_time, sdk_init_time)
 
         usage_stats_account_id = None
-        if instance.original_settings is not None:
-            usage_stats_account_id = instance.original_settings.get(
-                "usageStatsAccountId"
-            )
+        if getattr(instance, '_settings', None) is not None:
+            usage_stats_account_id = instance._settings.get_usage_stats_account_id()
 
         if usage_stats_account_id:
-            send_sdk_usage_stats_event(usage_stats_account_id)
+            sampling_service = InternalEventsSamplingService()
+            if sampling_service.should_send_usage_stats_event(instance._settings):
+                send_sdk_usage_stats_event(usage_stats_account_id)
 
         return instance
     except Exception as e:

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0/wingify_fme_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wingify-fme-python-sdk
-Version: 1.61.0
+Version: 1.62.0
 Summary: Wingify Feature Management and Experimentation SDK for Python
 Home-page: https://github.com/wingify/vwo-fme-python-sdk
 Author: Wingify

{wingify_fme_python_sdk-1.61.0 → wingify_fme_python_sdk-1.62.0}/wingify_fme_python_sdk.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ wingify/api/set_attribute_api.py
 wingify/api/track_api.py
 wingify/constants/Constants.py
 wingify/constants/__init__.py
+wingify/constants/sampled_debug_error_template_keys.py
 wingify/decorators/__init__.py
 wingify/decorators/storage_decorator.py
 wingify/enums/__init__.py
@@ -61,6 +62,7 @@ wingify/models/schemas/rule_schema.py
 wingify/models/schemas/settings_schema.py
 wingify/models/schemas/variable_schema.py
 wingify/models/settings/__init__.py
+wingify/models/settings/internal_event_sampling_settings_model.py
 wingify/models/settings/settings_model.py
 wingify/models/storage/__init__.py
 wingify/models/storage/storage_model.py
@@ -119,6 +121,7 @@ wingify/services/__init__.py
 wingify/services/batch_event_queue.py
 wingify/services/campaign_decision_service.py
 wingify/services/hooks_manager.py
+wingify/services/internal_events_sampling_service.py
 wingify/services/settings_manager.py
 wingify/services/storage_service.py
 wingify/services/url_service.py
@@ -135,6 +138,7 @@ wingify/utils/function_util.py
 wingify/utils/gateway_service_util.py
 wingify/utils/holdout_util.py
 wingify/utils/impression_util.py
+wingify/utils/internal_events_sampling_util.py
 wingify/utils/log_message_util.py
 wingify/utils/meg_util.py
 wingify/utils/model_utils.py