feat: send health check event

Author: sakshamg1304

CHANGELOG.md

@@ -4,13 +4,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.11.0] - 2025-07-21
+
+### Added
+
+- Added support for sending a one-time initialization event to the server to verify correct SDK setup.
+
 ## [1.10.1] - 2025-07-24
 
 ### Added
 
 - Send the SDK name and version in the settings call to VWO as query parameters.
 
-
 ## [1.10.0] - 2025-07-02
 
 ### Added

setup.py

@@ -121,7 +121,7 @@ def run(self):
 
 setup(
     name="vwo-fme-python-sdk",
-    version="1.10.1",
+    version="1.11.0",
     description="VWO Feature Management and Experimentation SDK for Python",
     long_description=long_description,
     long_description_content_type="text/markdown",

vwo/constants/Constants.py

@@ -17,7 +17,7 @@ class Constants:
     # TODO: read from setup.py
     sdk_meta = {
         "name": "vwo-fme-python-sdk",
-        "version": "1.10.1"
+        "version": "1.11.0"
     }
 
     # Constants

vwo/enums/event_enum.py

@@ -19,4 +19,5 @@
 class EventEnum(Enum):
     VWO_VARIATION_SHOWN = "vwo_variationShown"
     VWO_SYNC_VISITOR_PROP = "vwo_syncVisitorProp"
-    VWO_LOG_EVENT = "vwo_log"
+    VWO_LOG_EVENT = "vwo_log"
+    VWO_SDK_INIT_EVENT = "vwo_fmeSdkInit"

vwo/packages/network_layer/client/network_client.py

@@ -119,16 +119,7 @@ def post(self, request_model: RequestModel) -> ResponseModel:
 
                 if response.status_code < 200 or response.status_code >= 300:
                     raise requests.HTTPError(f"HTTP {response.status_code} error")
-
-                LogManager.get_instance().info(
-                    info_messages.get("NETWORK_CALL_SUCCESS").format(
-                        event=request_model.get_query().get("en"),
-                        endPoint=options["url"].split("?")[0],
-                        accountId=request_model.get_query().get("a"),
-                        userId=request_model.get_user_id(),
-                        uuid=request_model.get_body().get("d").get("visId"),
-                    )
-                )
+        
                 return response_model
 
             except (

vwo/resources/error-messages.json

@@ -28,5 +28,7 @@
     "BATCH_FLUSH_ERROR": "Error occurred while sending batch events. Error:{error}",
 
     "NETWORK_CALL_RETRY_ATTEMPT": "Request failed for {endPoint}, Error: {err}. Retrying in {delay} seconds, attempt {attempt} of {maxRetries}",
-    "NETWORK_CALL_RETRY_FAILED": "Max retries reached. Request failed for {endPoint}, Error: {err}"
+    "NETWORK_CALL_RETRY_FAILED": "Max retries reached. Request failed for {endPoint}, Error: {err}",
+
+    "SDK_INIT_EVENT_FAILED": "Error occurred while sending SDK init event. Error:{err}"
   }

vwo/services/settings_manager.py

@@ -13,8 +13,9 @@
 # limitations under the License.
 
 
+from typing import Any, Dict
+import random
 from ..packages.network_layer.manager.network_manager import NetworkManager
-from ..utils.network_util import get_settings_path
 from ..packages.network_layer.models.request_model import RequestModel
 from ..constants.Constants import Constants
 from ..packages.logger.core.log_manager import LogManager
@@ -23,6 +24,7 @@
 import json
 import requests
 import jsonschema
+import time
 
 
 class SettingsManager:
@@ -34,6 +36,8 @@ def __init__(self, options):
         self.expiry = Constants.SETTINGS_EXPIRY
         self.network_timeout = Constants.SETTINGS_TIMEOUT
         self.is_gateway_service_provided = False
+        self.settings_fetch_time = None  # time taken to fetch the settings
+        self.is_settings_valid_on_init = False
 
         if "gateway_service" in options and "url" in options["gateway_service"]:
             self.is_gateway_service_provided = True
@@ -94,14 +98,23 @@ def fetch_settings_and_cache_in_storage(self, update=False):
             )
             return None
 
+
+    def get_settings_path(self) -> Dict[str, Any]:
+        path = {
+            "i": self.sdk_key,  # Inject API key
+            "r": random.random(),  # Random number for cache busting
+            "a": self.account_id,  # Account ID
+        }
+        return path
+
     def fetch_settings(self, is_via_webhook=False):
         if not self.sdk_key or not self.account_id:
             raise ValueError(
                 "sdk_key is required for fetching account settings. Aborting!"
             )
 
         network_instance = NetworkManager.get_instance()
-        options = get_settings_path(self.sdk_key, self.account_id)
+        options = self.get_settings_path()
         options["platform"] = "server"
         options["api-version"] = 1
         options["sn"] = Constants.SDK_NAME
@@ -115,6 +128,8 @@ def fetch_settings(self, is_via_webhook=False):
             if not is_via_webhook
             else Constants.WEBHOOK_SETTINTS_ENDPOINT
         )
+        # Start timer for settings fetch
+        settings_fetch_start_time = time.time() * 1000  # Convert to milliseconds
 
         try:
             request = RequestModel(
@@ -134,6 +149,8 @@ def fetch_settings(self, is_via_webhook=False):
             if response.status_code != 200:
                 raise Exception(f"Failed to fetch settings: {response_data}")
 
+            # Calculate settings fetch time
+            self.settings_fetch_time = int((time.time() * 1000) - settings_fetch_start_time)
             return response_data
 
         except Exception as err:
@@ -147,6 +164,7 @@ def get_settings(self, force_fetch=False):
             # For demonstration, we'll skip actual caching
             fetched_settings = self.fetch_settings_and_cache_in_storage()
             if self.is_settings_valid(fetched_settings):
+                self.is_settings_valid_on_init = True
                 LogManager.get_instance().info(
                     info_messages.get("SETTINGS_FETCH_SUCCESS").format()
                 )

vwo/utils/event_util.py

@@ -0,0 +1,53 @@
+# Copyright 2024-2025 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 Optional
+from .network_util import get_events_base_properties, get_sdk_init_event_payload, send_event
+from ..enums.event_enum import EventEnum
+from ..vwo_client import VWOClient
+from ..packages.logger.core.log_manager import LogManager
+from ..utils.log_message_util import error_messages
+
+def send_sdk_init_event(settings_fetch_time: Optional[int] = None, sdk_init_time: Optional[int] = None) -> None:
+    """
+    Sends an init called event to VWO.
+    This event is triggered when the init function is called.
+    
+    :param settings_fetch_time: Time taken to fetch settings in milliseconds
+    :param sdk_init_time: Time taken to initialize the SDK in milliseconds
+    """
+    # Create the query parameters
+    properties = get_events_base_properties(EventEnum.VWO_SDK_INIT_EVENT.value)
+    
+    # Create the payload with required fields
+    payload = get_sdk_init_event_payload(EventEnum.VWO_SDK_INIT_EVENT.value, settings_fetch_time, sdk_init_time)
+    
+    # Send the constructed payload via POST request
+    try:
+        vwo_instance = VWOClient.get_instance()
+
+        # Check if batch events are enabled
+        if vwo_instance.batch_event_queue is not None:
+            # Enqueue the event to the batch queue
+            vwo_instance.batch_event_queue.enqueue(payload)
+        else:
+            # Send the event immediately if batch events are not enabled
+            send_event(properties, payload, EventEnum.VWO_SDK_INIT_EVENT.value)
+    except Exception as e:
+        LogManager.get_instance().error(
+            error_messages.get("SDK_INIT_EVENT_FAILED").format(
+                err=str(e)
+            )
+        )
+        pass 

vwo/utils/log_message_util.py

@@ -57,7 +57,7 @@ def send_log_to_vwo(message: str, message_type: str) -> None:
     from ..utils.network_util import (
         get_events_base_properties,
         get_messaging_event_payload,
-        send_messaging_event,
+        send_event,
     )
 
     if os.getenv("TEST_ENV") == "true":
@@ -80,4 +80,4 @@ def send_log_to_vwo(message: str, message_type: str) -> None:
         )
 
         # Send the message via HTTP request
-        send_messaging_event(properties, payload)
+        send_event(properties, payload, EventEnum.VWO_LOG_EVENT.value)

vwo/utils/network_util.py

@@ -33,16 +33,8 @@
 from ..packages.network_layer.models.request_model import RequestModel
 from ..enums.headers_enum import HeadersEnum
 from ..utils.usage_stats_util import UsageStatsUtil
-
-
-def get_settings_path(sdk_key: str, account_id: str) -> Dict[str, Any]:
-    path = {
-        "i": sdk_key,  # Inject API key
-        "r": random.random(),  # Random number for cache busting
-        "a": account_id,  # Account ID
-    }
-    return path
-
+from ..services.settings_manager import SettingsManager
+from ..enums.event_enum import EventEnum
 
 # Function to construct tracking path for an event
 def get_track_event_path(event: str, account_id: str, user_id: str) -> Dict[str, Any]:
@@ -69,7 +61,6 @@ def get_event_batching_query_params(account_id: str) -> Dict[str, Any]:
 def get_events_base_properties(
     event_name: str, visitor_user_agent: str = "", ip_address: str = ""
 ) -> Dict[str, Any]:
-    from ..services.settings_manager import SettingsManager
 
     # Get the instance of SettingsManager
     settings = SettingsManager.get_instance()
@@ -101,7 +92,6 @@ def _get_event_base_payload(
     visitor_user_agent: str = "",
     ip_address: str = "",
 ) -> Dict[str, Any]:
-    from ..services.settings_manager import SettingsManager
 
     uuid_value = get_uuid(user_id, SettingsManager.get_instance().get_account_id())
     sdk_key = SettingsManager.get_instance().get_sdk_key()
@@ -221,9 +211,6 @@ def get_attribute_payload_data(
 def send_post_api_request(
     properties: Dict[str, Any], payload: Dict[str, Any], user_id: str
 ):
-    # Importing the SettingsManager here to avoid circular import issues or unnecessary imports
-    from ..services.settings_manager import SettingsManager
-
     try:
         # Initialize the headers dictionary for the request
         headers = {}
@@ -263,6 +250,17 @@ def send_request():
                 if response.status_code == 200:
                     # clear the usage stats data
                     UsageStatsUtil().clear_usage_stats()
+                    
+                    request_query = request.get_query()
+                    LogManager.get_instance().info(
+                        info_messages.get("NETWORK_CALL_SUCCESS").format(
+                            event=request_query.get("en"),
+                            endPoint=request.get_url().split("?")[0],
+                            accountId=request_query.get("a"),
+                            userId=request.get_user_id(),
+                            uuid=request.get_body().get("d").get("visId"),
+                        )
+                    )
             except Exception as e:
                 LogManager.get_instance().error(
                     error_messages.get("NETWORK_CALL_FAILED").format(
@@ -289,7 +287,6 @@ def send_request():
 def send_post_batch_request(
     payload: dict, account_id: int, sdk_key: str, flush_callback=None
 ):
-    from ..services.settings_manager import SettingsManager
 
     try:
         # Prepare the batch payload
@@ -313,6 +310,7 @@ def send_post_batch_request(
             SettingsManager.get_instance().port,
         )
 
+        request_model.set_user_id("NA")
         # Call PostAsync to send the request asynchronously
         network_manager = NetworkManager.get_instance()
         response = network_manager.post(request_model)
@@ -345,8 +343,6 @@ def send_post_batch_request(
 def get_messaging_event_payload(
     message_type: str, message: str, event_name: str
 ) -> Dict[str, Any]:
-    from ..services.settings_manager import SettingsManager
-
     # Get user ID and properties
     settings = SettingsManager.get_instance()
     user_id = f"{settings.get_account_id()}_{settings.get_sdk_key()}"
@@ -373,20 +369,65 @@ def get_messaging_event_payload(
     return properties
 
 
-def send_messaging_event(
-    properties: Dict[str, Any], payload: Dict[str, Any]
+def get_sdk_init_event_payload(
+    event_name: str,
+    settings_fetch_time: Optional[int] = None,
+    sdk_init_time: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Constructs the payload for sdk init called event.
+    
+    Args:
+        event_name: The name of the event.
+        settings_fetch_time: Time taken to fetch settings in milliseconds.
+        sdk_init_time: Time taken to initialize the SDK in milliseconds.
+        
+    Returns:
+        The constructed payload with required fields.
+    """
+    # Get user ID and properties
+    settings = SettingsManager.get_instance()
+    user_id = f"{settings.get_account_id()}_{settings.get_sdk_key()}"
+    properties = _get_event_base_payload(None, user_id, event_name, None, None)
+
+    # Set the required fields as specified
+    properties["d"]["event"]["props"][Constants.VWO_FS_ENVIRONMENT] = settings.get_sdk_key()
+    properties["d"]["event"]["props"]["product"] = "fme"
+    
+    data = {
+        "isSDKInitialized": True,
+        "settingsFetchTime": settings_fetch_time,
+        "sdkInitTime": sdk_init_time,
+    }
+    properties["d"]["event"]["props"]["data"] = data
+
+    return properties
+
+
+def send_event(
+    properties: Dict[str, Any], payload: Dict[str, Any], event_name: str
 ) -> Dict[str, Any]:
     try:
+        #if event_name is not VWO_LOG_EVENT, then set base url to constants.hostname
+        if event_name == EventEnum.VWO_LOG_EVENT.value:
+            base_url = Constants.HOST_NAME
+            protocol = Constants.HTTPS_PROTOCOL
+            port = 443
+        else:
+            base_url = UrlService.get_base_url()
+            protocol = SettingsManager.get_instance().protocol
+            port = SettingsManager.get_instance().port
+
         # Create the request model
         request = RequestModel(
-            Constants.HOST_NAME,
+            base_url,
             "POST",
             UrlEnum.EVENTS.value,
             properties,
             payload,
             None,
-            Constants.HTTPS_PROTOCOL,
-            443,
+            protocol,
+            port,
         )
 
         # Get network instance