Initialization
To create a Wingify Client instance, you need to initialize the Wingify FE Ruby SDK. This client instance serves as the core interface for conducting Feature Experimentation(A/B and personalization) within your application.
#Usage
require 'wingify'
# Initialize Wingify client
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key'
})
The init() function is called with the sdk_keyand account_id. It initializes and returns a Wingify Client Objectwingify_client, which can be used to perform feature
This client object allows you to run experiments, track events, and enable/disable feature flags.
#Parameter Definitions
| Parameter |
|---|
| **account\_id** _Required_ |
#Poll Interval (Keeping Wingify client up-to-date)
When you initialize the wingify_client on your server, it pulls the latest configurations you've done in the Wingify application.
If/when you make any changes to the feature flags or rules within Wingify after the wingify_client has been initialized in your server, there needs to be some way to update your wingify_client with the latest settings from. This can be done via polling.
The poll interval is an optional parameter that allows the SDK to automatically fetch and update settings from the Wingify server at specified intervals. Setting this parameter ensures your application always uses the latest configuration.
# Init options with poll_interval
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
poll_interval: 60000
});
#Logger
Wingify by default logs all ERROR level messages to your server console. To gain more control over Wingify's logging behavior, you can use the logger parameter in the init configuration.
# Init options with logger
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
logger: {
level: 'DEBUG'
}
})
Please click here for more advanced logger options.
#Storage
By default, the SDK operates in stateless mode, evaluating flags on each get_flag call. To improve performance and consistency, you can use a custom storage mechanism to cache decisions, ensuring stable user experiences and reducing application load.
# Init options with storage
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
storage: StorageConnector.new
})
Please click here to learn more about storage implementation.
#Gateway Service
The Wingify FE Gateway Service enhances Feature Experimentation (FE) SDKs by enabling pre-segmentation based on user location and user agent. It ensures minimal latency and improved security. The service can be customized via the gateway_service parameter during initialization.
# Init options with gateway_service
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
gateway_service: {
url: 'http://custom.gateway.com',
},
});
Please click here to learn more about gateway service.
#Integrations
Wingify FE SDKs provide seamless integration with third-party tools like analytics platforms, monitoring services, customer data platforms (CDPs), and messaging systems. This is achieved through a simple yet powerful callback mechanism that receives Wingify-specific properties and can forward them to any third-party tool of your choice.
def callback(data)
puts "Integration data: #{data}"
end
# Init options with integrations
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
integrations: {
callback: method(:callback)
}
})
Please click here to learn more about Integrations,.
#Threading
The SDK leverages threading to efficiently manage concurrent operations. Threading is enabled by default, but can be disabled by configuring the threading parameter during initialization. This gives you control over the SDK's concurrency behavior based on your application's needs.
Disable Threading: When threading is disabled, all tracking calls will block the main execution thread until they complete. This means your application will wait for each Wingify operation before continuing.
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
threading: {
enabled: false
},
})
Enable Threading (Default): When enabled, all tracking calls are processed asynchronously in the background. This prevents these network calls from blocking your application's main execution flow. The SDK uses a thread pool to manage these concurrent operations efficiently. The default pool size of 5 threads is suitable for most applications, but you can adjust it based on your needs:
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
threading: {
enabled: true,
max_pool_size: 10
},
})
#Retry Configuration
The SDK includes a built-in retry mechanism to improve reliability when network requests fail due to transient issues such as timeouts or temporary connectivity problems. You can fully control this behavior by providing a retryConfig object during SDK initialization.
wingify_client = Wingify.init({
account_id: '123456',
sdk_key: '32-alpha-numeric-sdk-key',
retry_config : {
should_retry: true,
max_retries: 3,
initial_delay: 2,
backoff_multiplier: 2
}
})
Please click
#Proxy URL
The proxy_url parameter allows you to redirect all SDK network calls through a custom proxy server. This feature enables you to route all SDK network requests (settings, tracking, etc.) through your own proxy server, providing better control over network traffic and security.
How to Use Proxy URL
The proxy URL can be configured by passing the proxy_url parameter in the init configuration.
wingify_client = Wingify.init({
sdk_key: '32-alpha-numeric-sdk-key',
account_id: '123456',
proxy_url: 'https://custom.proxy.com'
})
Please click