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

{wingify_fme_python_sdk-1.60.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.60.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.60.0 → wingify_fme_python_sdk-1.62.0}/setup.py

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

{wingify_fme_python_sdk-1.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/api/get_flag_api.py

@@ -41,7 +41,11 @@ from ..utils.impression_util import (
 from ..models.user.get_flag import GetFlag
 from ..services.storage_service import StorageService
 from ..decorators.storage_decorator import StorageDecorator
-from ..utils.campaign_util import get_variation_from_campaign_key
+from ..utils.campaign_util import (
+    get_experiment_key,
+    get_rollout_key,
+    get_variation_from_campaign_key,
+)
 from ..enums.debug_category_enum import DebugCategoryEnum
 from ..packages.logger.enums.log_level_enum import LogLevelEnum
 from ..constants.Constants import Constants
@@ -392,7 +396,7 @@ class GetFlagApi:
 
                     self._evaluated_feature_map[feature_key] = {
                         "rolloutId": rule.get_id(),
-                        "rolloutKey": rule.get_key(),
+                        "rolloutKey": get_rollout_key(rule, feature_key),
                         "rolloutVariationId": (
                             rule.get_variations()[0].get_id()
                             if rule.get_variations()
@@ -493,7 +497,9 @@ class GetFlagApi:
                         self._passed_rules_information.update(
                             {
                                 "experimentId": rule.get_id(),
-                                "experimentKey": rule.get_key(),
+                                "experimentKey": get_experiment_key(
+                                    rule, feature.get_key()
+                                ),
                                 "experimentVariationId": whitelisted_object[
                                     "variationId"
                                 ],
@@ -627,7 +633,9 @@ class GetFlagApi:
             self._passed_rules_information.update(
                 {
                     "rolloutId": campaign.get_id(),
-                    "rolloutKey": campaign.get_key(),
+                    "rolloutKey": get_rollout_key(
+                        campaign, decision.get("featureKey")
+                    ),
                     "rolloutVariationId": variation.get_id(),
                 }
             )
@@ -635,7 +643,9 @@ class GetFlagApi:
             self._passed_rules_information.update(
                 {
                     "experimentId": campaign.get_id(),
-                    "experimentKey": campaign.get_key(),
+                    "experimentKey": get_experiment_key(
+                        campaign, decision.get("featureKey")
+                    ),
                     "experimentVariationId": variation.get_id(),
                 }
             )

{wingify_fme_python_sdk-1.60.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.60.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.60.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.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/packages/segmentation_evaluator/core/segmentation_manager.py

@@ -85,14 +85,25 @@ class SegmentationManager:
 
         # Check if any holdout requires gateway service
         holdouts = settings.get_holdouts() or []
-        is_gateway_service_required_for_holdouts = len(list(filter(lambda holdout: holdout.get_is_gateway_service_required(), holdouts))) > 0
-        # Call gateway service if required for segmentation OR if gateway service is provided and user agent is available
+        is_gateway_service_required_for_holdouts = len(
+            list(
+                filter(
+                    lambda holdout: holdout.get_is_gateway_service_required(), holdouts
+                )
+            )
+        ) > 0
+        is_segmentation_gateway_required = (
+            feature.get_is_gateway_service_required()
+            or is_gateway_service_required_for_holdouts
+        )
+        # Call get-user-details only when gateway_service is configured and
+        # segmentation (feature or holdout) requires gateway data.
+        # proxy_url alone must never trigger a gateway call.
         should_call_gateway_service = (
-            (feature.get_is_gateway_service_required() and not SettingsManager.get_instance().is_on_platform_host()) or
-            (not SettingsManager.get_instance().is_on_platform_host() and
-             (context.get_user_agent() or context.get_ip_address()))
-        ) or is_gateway_service_required_for_holdouts
-        
+            SettingsManager.get_instance().is_gateway_service_provided
+            and is_segmentation_gateway_required
+        )
+
         if should_call_gateway_service and context.get_vwo() is None:
             query_params = {}
             if not context.get_user_agent() and not context.get_ip_address():

{wingify_fme_python_sdk-1.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/resources/error-messages.json

@@ -12,13 +12,15 @@
     "UPDATING_CLIENT_INSTANCE_FAILED_WHEN_WEBHOOK_TRIGGERED": "Failed to fetch settings. {brand} client instance couldn't be updated. API:{apiName} called having isViaWebhook:{isViaWebhook}. Error: {err}",
   
     "EXECUTION_FAILED": "API - {apiName} failed to execute. Error:{err}",
+    "INTEGRATIONS_CALLBACK_FAILED": "Error while executing integrations_callback: Error: {err}",
     "INVALID_PARAM": "Key:{key} passed to API:{apiName} is not of valid type. Got type:{type}, should be:{correctType}",
     "INVALID_CONTEXT_PASSED": "Context should be of type:object and must contain a mandatory key: id, which is User ID",
+    "INVALID_CONTEXT_USER_ID": "user_id under context must be a string value",
     "INVALID_BUCKETING_SEED": "Invalid bucketingSeed passed, since it can only be a valid string. Removing it from context so that userId is used for decisioning.",
   
     "FEATURE_NOT_FOUND": "Feature not found for the key:{featureKey}",
     "FEATURE_NOT_FOUND_WITH_ID": "Feature not found for the id:{featureId}",
-    "EVENT_NOT_FOUND": "Event:{eventName} not found in any of the features' metrics",
+    "EVENT_NOT_FOUND": "Event:{eventName} not found in any of the features' metrics, please ensure event API name is being used correctly",
   
     "ERROR_READING_STORED_DATA_IN_STORAGE": "Error reading data from storage. Error:{err}",
     "ERROR_STORING_DATA_IN_STORAGE": "Key:{featureKey} is not valid. Unable to store data into storage",

{wingify_fme_python_sdk-1.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/services/hooks_manager.py

@@ -14,6 +14,7 @@
 
 
 from typing import Callable, Dict, Any, Optional
+from ..packages.logger.core.log_manager import LogManager
 
 
 class HooksManager:
@@ -36,7 +37,15 @@ class HooksManager:
         :param properties: A dictionary of properties to pass to the callback.
         """
         if self.is_callback_function and self.callback:
-            self.callback(properties)
+            try:
+                self.callback(properties)
+            except Exception as err:
+                LogManager.get_instance().error_log(
+                    "INTEGRATIONS_CALLBACK_FAILED",
+                    data={"err": str(err)},
+                    debug_data={"an": properties.get("api")},
+                    should_send_log_to_vwo=False,
+                )
 
     def set(self, properties: Dict[str, Any]) -> None:
         """

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.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/utils/campaign_util.py

@@ -27,6 +27,69 @@ import math
 from ..models.user.context_model import ContextModel
 
 
+def _resolve_feature_rule_key(
+    campaign: CampaignModel, feature_key: Optional[str] = None
+) -> Optional[str]:
+    """
+    Resolves ``{featureKey}_{ruleKey}`` when rules share a parent campaign key.
+
+    Args:
+        campaign (CampaignModel): The campaign containing the rule key.
+        feature_key (Optional[str]): Feature key; inferred from campaign key if omitted.
+
+    Returns:
+        Optional[str]: Resolved rule key, or ``None`` if rule key is missing.
+    """
+    if not campaign.get_rule_key():
+        return None
+    resolved_feature_key = feature_key
+    if not resolved_feature_key and campaign.get_key():
+        resolved_feature_key = campaign.get_key().rsplit("_", 1)[0]
+    if resolved_feature_key:
+        return f"{resolved_feature_key}_{campaign.get_rule_key()}"
+    return None
+
+
+def get_experiment_key(
+    campaign: CampaignModel, feature_key: Optional[str] = None
+) -> str:
+    """
+    Returns the experiment key for integrations callbacks and storage.
+
+    Args:
+        campaign (CampaignModel): The campaign to resolve the key for.
+        feature_key (Optional[str]): Feature key for personalize rules.
+
+    Returns:
+        str: ``{featureKey}_{ruleKey}`` for personalize rules; otherwise campaign key.
+    """
+    if campaign.get_type() == CampaignTypeEnum.PERSONALIZE.value:
+        rule_key = _resolve_feature_rule_key(campaign, feature_key)
+        if rule_key:
+            return rule_key
+    return campaign.get_key()
+
+
+def get_rollout_key(
+    campaign: CampaignModel, feature_key: Optional[str] = None
+) -> str:
+    """
+    Returns the rollout key for integrations callbacks and storage.
+
+    Args:
+        campaign (CampaignModel): The campaign to resolve the key for.
+        feature_key (Optional[str]): Feature key for rollout rules.
+
+    Returns:
+        str: ``{featureKey}_{ruleKey}`` for rollout rules; otherwise campaign key.
+    """
+    if campaign.get_type() == CampaignTypeEnum.ROLLOUT.value:
+        rule_key = _resolve_feature_rule_key(campaign, feature_key)
+        if rule_key:
+            return rule_key
+    return campaign.get_key()
+
+
 def set_variation_allocation(campaign: CampaignModel) -> None:
     """
     Allocates traffic ranges to variations within a campaign.
@@ -176,6 +239,24 @@ def get_variation_from_campaign_key(
         if variation:
             return variation
 
+    for feature in settings.get_features() or []:
+        feature_key = feature.get_key()
+        for linked_campaign in feature.get_rules_linked_campaign() or []:
+            if (
+                get_experiment_key(linked_campaign, feature_key) == campaign_key
+                or get_rollout_key(linked_campaign, feature_key) == campaign_key
+            ):
+                variation = next(
+                    (
+                        v
+                        for v in linked_campaign.get_variations()
+                        if v.get_id() == variation_id
+                    ),
+                    None,
+                )
+                if variation:
+                    return variation
+
     return None
 
 

{wingify_fme_python_sdk-1.60.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.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/utils/meg_util.py

@@ -29,6 +29,8 @@ from ..utils.campaign_util import (
     get_bucketing_seed,
     get_campaign_ids_from_feature_key,
     get_campaigns_by_group_id,
+    get_experiment_key,
+    get_rollout_key,
     get_feature_keys_from_campaign_ids,
     set_campaign_allocation,
     get_variation_from_campaign_key,
@@ -207,7 +209,7 @@ def _is_rollout_rule_for_feature_passed(
                 if isinstance(variation, VariationModel) and not None:
                     evaluated_feature_map[feature.get_key()] = {
                         "rolloutId": rule.get_id(),
-                        "rolloutKey": rule.get_key(),
+                        "rolloutKey": get_rollout_key(rule, feature.get_key()),
                         "rolloutVariationId": rule.get_variations()[0].get_id(),
                     }
                     return True
@@ -241,7 +243,8 @@ def _get_eligible_campaigns(
             )
 
             if stored_data and stored_data.get("experimentVariationId"):
-                if stored_data.get("experimentKey") == campaign.get_key():
+                campaign_experiment_key = get_experiment_key(campaign, feature_key)
+                if stored_data.get("experimentKey") == campaign_experiment_key:
                     variation = get_variation_from_campaign_key(
                         settings,
                         stored_data["experimentKey"],
@@ -261,7 +264,8 @@ def _get_eligible_campaigns(
                             )
                         )
                         if not any(
-                            item.get_key() == campaign.get_key()
+                            get_experiment_key(item, feature_key)
+                            == campaign_experiment_key
                             for item in eligible_campaigns_with_storage
                         ):
                             eligible_campaigns_with_storage.append(
@@ -428,7 +432,7 @@ def _normalize_weights_and_find_winning_campaign(
                 "featureKey": Constants.VWO_META_MEG_KEY + str(group_id),
                 "context": context,
                 "experimentId": winner_campaign.get_id(),
-                "experimentKey": winner_campaign.get_key(),
+                "experimentKey": get_experiment_key(winner_campaign),
                 "experimentVariationId": (
                     winner_campaign.get_variations()[0].get_id()
                     if winner_campaign.get_type() == CampaignTypeEnum.PERSONALIZE.value
@@ -538,7 +542,7 @@ def _get_campaign_using_advanced_algo(
                 "featureKey": Constants.VWO_META_MEG_KEY + str(group_id),
                 "context": context,
                 "experimentId": winner_campaign.get_id(),
-                "experimentKey": winner_campaign.get_key(),
+                "experimentKey": get_experiment_key(winner_campaign),
                 "experimentVariationId": (
                     winner_campaign.get_variations()[0].get_id()
                     if winner_campaign.get_type() == CampaignTypeEnum.PERSONALIZE.value

{wingify_fme_python_sdk-1.60.0 → wingify_fme_python_sdk-1.62.0}/wingify/utils/rule_evaluation_util.py

@@ -19,6 +19,7 @@ from ..models.campaign.feature_model import FeatureModel
 from ..models.user.context_model import ContextModel
 from ..utils.data_type_util import is_object
 from ..utils.decision_util import check_whitelisting_and_pre_seg
+from ..utils.campaign_util import get_experiment_key
 from ..services.storage_service import StorageService
 from ..utils.network_util import get_track_user_payload_data
 from typing import Dict
@@ -74,7 +75,7 @@ def evaluate_rule(
         decision.update(
             {
                 "experimentId": campaign.get_id(),
-                "experimentKey": campaign.get_key(),
+                "experimentKey": get_experiment_key(campaign, feature.get_key()),
                 "experimentVariationId": whitelisted_object["variationId"],
             }
         )