Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

This release introduces Wingify as the primary SDK branding and package namespace, while keeping existing VWO integrations fully supported.

• Wingify public API - use WingifyFme, WingifyInitOptions, and WingifyUserContext from Wingify_FME as the recommended entry point for new integrations.

import Wingify_FME

let options = WingifyInitOptions(
    sdkKey: "32-alpha-numeric-sdk-key",
    accountId: 123456
)

WingifyFme.initialize(options: options) { result in
    switch result {
    case .success:
        let context = WingifyUserContext(id: "user-123")
        let flag = WingifyFme.getFlag(featureKey: "feature-key", context: context)
        _ = flag?.isEnabled()
    case .failure(let error):
        print(error.localizedDescription)
    }
}

• The SDK now provides Wingify-branded APIs and package import (Wingify_FME) for new integrations.
• Log messages and documentation have been updated to reflect Wingify branding.
• No breaking changes for existing integrations - server event names, payload keys, and runtime behavior remain compatible with the VWO platform.

The following VWO symbols are deprecated but continue to work without modification:

Existing code does not need to change immediately. We recommend adopting the Wingify API for new projects and migrating when convenient:

// Still supported - no action required today
import VWO_FME

let options = VWOInitOptions(
    sdkKey: "32-alpha-numeric-sdk-key",
    accountId: 123456
)

VWOFme.initialize(options: options) { result in
    switch result {
    case .success:
        let context = VWOUserContext(id: "user-123")
        _ = VWOFme.getFlag(featureKey: "feature-key", context: context)
    case .failure(let error):
        print(error.localizedDescription)
    }
}

Migration tip: Replace VWOFme -> WingifyFme, VWOInitOptions -> WingifyInitOptions, and VWOUserContext -> WingifyUserContext, and update imports from VWO_FME to Wingify_FME. Method signatures and SDK behavior are unchanged.

Updated gateway user details request context handling to include ipAddress only when gateway configuration is present in VWOInitOptions.

Fetch settings parallelly even when cache is not expired

• Introduced holdout group support for feature flags and events, including holdout settings in the configuration, SDK-side holdout evaluation, and exclusion of users in holdout groups from feature rollouts and experiments.

• Stability and performance improvements: Enhanced Core Data handling for more reliable store initialization and improved thread-safety in concurrent network.

• Added support for cachedDecisionExpiryTime, allowing cached flag decisions to automatically expire and be cleared after the configured time interval.

// Decisions expire after 60 seconds (60_000 ms); re-evaluation happens on the next getFlag call
 let options = VWOInitOptions(sdkKey: SDK_KEY, accountId: ACCOUNT_ID, cachedDecisionExpiryTime: 60000)

• Optimize network monitoring and event synchronization

• Refactored the SDK to provide support for multiple instances. Previously, the SDK was singleton-based, which caused state to be shared across multiple SDK instances. Now, you can create any number of SDK instances, each with its own isolated utils, services, and associated state.

import VWO_FME

// Initialize first instance
let options1 = VWOInitOptions(
    sdkKey: "first_sdk_key",
    accountId: 123456,
    logLevel: .info,
    logPrefix: "Instance1",
    batchUploadTimeInterval: 60000  // 1 minute
)

VWOFme.initialize(options: options1) { result in
    switch result {
    case .success:
        print("First instance initialized")

        let userContext1 = VWOUserContext(id: "user_123")
        VWOFme.getFlag(featureKey: "feature_1", context: userContext1) { flag in
            // Use flag from first instance
        }
    case .failure(let error):
        print("First instance initialization failed: \(error)")
    }
}

// Initialize second instance with different configuration
let options2 = VWOInitOptions(
    sdkKey: "second_sdk_key",
    accountId: 789012,
    logLevel: .debug,
    logPrefix: "Instance2",
    batchUploadTimeInterval: 120000  // 2 minutes
)

VWOFme.initialize(options: options2) { result in
    switch result {
    case .success:
        print("Second instance initialized")

        let userContext2 = VWOUserContext(id: "user_456")
        VWOFme.getFlag(featureKey: "feature_2", context: userContext2) { flag in
            // Use flag from second instance
        }
    case .failure(let error):
        print("Second instance initialization failed: \(error)")
    }
}

Each SDK instance maintains its own:

• Settings and configuration
• Services (storage, logger, network layer, etc.)
• Utils and helper functions
• State and cached data

This ensures complete isolation between instances, allowing you to safely use multiple VWO accounts or environments in the same application without any interference.

• Prevent API call retries when invalid credentials are provided.

• Enhanced Logging capabilities at VWO by sending vwo_sdkDebug event with additional debug properties.

• Fixed issue where getVariable() and getVariables() returned fallback/empty values when fetching user data from storage for rollout rule.

• Introducing alias ID support - associate original user ID with it's temporary ID for easier identity management and better reporting.

• Added support for multiple VWO FME initialization with proper concurrency handling to prevent crashes.

• Smarter Segmentation: Attribute Support for Pre/Post Custom Variables

• Sends usage statistics to VWO servers automatically during SDK initialization
• Added compatibility with Objective-C projects.

• Update UserAgent to support Device Type.

• Added support for sending a one-time SDK initialization event to VWO server as part of health-check milestones.

• Send the SDK name and version in the events and batching call to VWO as query parameters.

• Added the SDK name and version in the settings call to VWO as query parameters.

• Added support for using custom storage instead of built-in App storage.

   import VWO_FME

    let options = VWOInitOptions(sdkKey: SDK_KEY,
                             accountId: ACCOUNT_ID,
                             gatewayService: ["url": "REPLACE_WITH_GATEWAY_URL"],
                             cachedSettingsExpiryTime: 10 * 60 * 1000, // in milliseconds
                             pollInterval: nil,
                             storage: CustomStorage.shared)

    VWOFme.initialize(options: options) { result in
        switch result {
            case .success(let message):
                print("VWO init success")

            case .failure(let error):
                print("VWO init failed")
        }
    }

    class CustomStorage : VWOStorageConnector {

        static let shared = CustomStorage()
        private init() {}

        func set(_ value: Any?, forKey key: String) {
            // Use key and value to store
        }

        func getData(forKey key: String) -> Data? {
            // Use key to retrieve data
        }

    }

• Support to use Device ID if context.id is not available

   let userContext = VWOUserContext(customVariables: customVariables, shouldUseDeviceIdAsUserId: true)

• Platform support for tvOS, macOS, and watchOS.

• Expanded test coverage.

• Enhanced tracking and collection of usage statistics for SDK features and configurations, providing valuable insights for analytics.
• Added comprehensive test cases for core SDK functionalities.

• Renamed VWOContext to VWOUserContext for improved clarity and consistency across other SDKs.

• Fixed schema validation error that occurred when no feature flags were configured or in running state in the VWO application.
• Fix for segmentation operators to handle mixed-type comparisons.

• Added support to use DACDN as a substitute for the Gateway Service.

• Added LogTransport protocol, it serves as a bridge to capture and redirect log messages from the native SDK to external systems.
• Added support for uploading error messages to VWO.

• Added support for custom salt values in campaign rules to ensure consistent user bucketing across different campaigns. This allows multiple campaigns to share the same salt value, resulting in users being assigned to the same variations across those campaigns. Salt for a campaign can be configured inside VWO application only when the campaign is in the draft state.
• Support for sending multiple attributes at once.

    let attributeName1 = "attribute-name-string"
    let attributeValue1 = "attribute-value-text"
    let attributeName2 = "attribute-name-float"
    let attributeValue2 = 7.0
    let attributeDict: [String: Any] = [attributeName1: attributeValue1,
                                        attributeName2: attributeValue2]
    VWOFme.setAttribute(attributes: [attributeDict], context: userContext)

• Support for configuring SDK when linking with VWO Mobile Insights SDK. This can be configured by setting session data received via callback from Mobile Insights SDK via FmeConfig.

    //The `VWOSessionCallback` protocol in Mobile Insights SDK includes a callback method to provide session information
     func vwoScreenCaptureSessionDidUpdate(data: [String : Any]) {
         FmeConfig.setSessionData(data)
     }

• Fix for crash during SDK initialization when loading model from bundle via Cocoapods.

• Added support for storing impression events while the device is offline, ensuring no data loss. These events are batched and seamlessly synchronized with VWO servers once the device reconnects to the internet.
• Online event batching, allowing synchronization of impression events while the device is online. This feature can be configured by setting either the minimum batch size or the batch upload time interval during SDK initialization.

• Support for passing SDK name and version for hybrid SDKs i.e. React Native & Flutter SDKs

• Added support for Personalise rules within Mutually Exclusive Groups.
• Storage support: Built in storage capabilities to manage feature and variation data and preventing changes in variations upon each initialization.
• Settings cache: Cached settings will be used till it expires. Client can set the expiry time of cache.
• Added SPM support.

import VWO_FME

let options = VWOInitOptions(sdkKey: SDK_KEY,
                             accountId: ACCOUNT_ID,
                             gatewayService: ["url": "REPLACE_WITH_GATEWAY_URL"],
                             cachedSettingsExpiryTime: 10 * 60 * 1000) // in milliseconds

VWOFme.initialize(options: options) { result in
    switch result {
        case .success(let message):
            print("VWO init success")

        case .failure(let error):
            print("VWO init failed")
    }
}

• Added integration support with VWO Gateway Service

import VWO_FME

let options = VWOInitOptions(sdkKey: sdkKey, accountId: accountId, gatewayService: ["url": "REPLACE_WITH_GATEWAY_URL"])

VWOFme.initialize(options: options) { result in
    switch result {
        case .success(let message):
            print("VWO init success")

        case .failure(let error):
            print("VWO init failed")
    }
}

let userContext = VWOContext(
    id: USER_ID,
    ipAddress: "1.2.3.4", // pass actual IP Address
    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148" // pass actual user agent
)

let featureFlagObj = VWOFme.getFlag(featureKey: FEATURE_KEY, context: userContext)

• First release of VWO Feature Management and Experimentation capabilities

  import VWO_FME
  
  // Initialize VWO SDK with your SDK_KEY and ACCOUNT_ID
  let options = VWOInitOptions(sdkKey: SDK_KEY, accountId: ACCOUNT_ID)
  
  VWOFme.initialize(options: options) { result in
      switch result {
          case .success(let message):
              print("VWO init success")
  
              // for targeting conditions
              let customVariables: [String : Any] = ["key_1": 2, "key_2": 0]
              // Create VWOContext object
              let userContext = VWOContext(id: "unique_user_id", customVariables: customVariables)
  
              // Get the GetFlag object for the feature key and context
              let featureFlagObj = VWOFme.getFlag(featureKey: "feature_flag_name", context: userContext)
  
              // Check if flag is enabled
              let isFlagEnabled = featureFlagObj?.isEnabled()
  
              // Get the variable value for the given variable key and default value
              let variable1 = featureFlagObj?.getVariable(key: "feature_flag_variable1", defaultValue: "default-value1")
  
              // Track the event for the given event name and context
              let eventProperties: [String: Any] = ["cart_value":"999"]
              VWOFme.trackEvent(eventName: "vwo_event_name", context: userContext, eventProperties: eventProperties)
  
              // Send attributes data
              let attributeName = "attribute-name"
              let attributeValue = "attribute-value"
              VWOFme.setAttribute(attributeKey: attributeName , attributeValue: attributeValue, context: userContext)
  
  
          case .failure(let error):
              break
      }
  }