{"id":19541315,"url":"https://github.com/wingify/vwo-fme-java-sdk","last_synced_at":"2026-02-18T05:14:40.683Z","repository":{"id":242061535,"uuid":"808573655","full_name":"wingify/vwo-fme-java-sdk","owner":"wingify","description":"VWO Feature Management and Experimentation SDK for Java","archived":false,"fork":false,"pushed_at":"2026-02-11T09:21:36.000Z","size":325,"stargazers_count":7,"open_issues_count":0,"forks_count":0,"subscribers_count":5,"default_branch":"master","last_synced_at":"2026-02-11T17:49:44.430Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"https://developers.vwo.com/v2/docs/fme-java","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/wingify.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":"NOTICE","maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2024-05-31T10:54:17.000Z","updated_at":"2026-02-11T09:21:40.000Z","dependencies_parsed_at":"2024-12-24T09:23:50.200Z","dependency_job_id":"1e9f275e-6573-4b35-be6b-d6b2b56e97d5","html_url":"https://github.com/wingify/vwo-fme-java-sdk","commit_stats":null,"previous_names":["wingify/vwo-fme-java-sdk"],"tags_count":22,"template":false,"template_full_name":null,"purl":"pkg:github/wingify/vwo-fme-java-sdk","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wingify%2Fvwo-fme-java-sdk","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wingify%2Fvwo-fme-java-sdk/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wingify%2Fvwo-fme-java-sdk/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wingify%2Fvwo-fme-java-sdk/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/wingify","download_url":"https://codeload.github.com/wingify/vwo-fme-java-sdk/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/wingify%2Fvwo-fme-java-sdk/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29569856,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-18T04:18:28.490Z","status":"ssl_error","status_checked_at":"2026-02-18T04:13:49.018Z","response_time":162,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-11-11T03:09:37.782Z","updated_at":"2026-02-18T05:14:35.674Z","avatar_url":"https://github.com/wingify.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# VWO Feature Management and Experimentation SDK for Java\n\n[![CI](https://github.com/wingify/vwo-fme-java-sdk/workflows/CI/badge.svg?branch=master)](https://github.com/wingify/vwo-fme-java-sdk/actions?query=workflow%3ACI)\n[![codecov](https://codecov.io/gh/wingify/vwo-fme-java-sdk/branch/master/graph/badge.svg?token=WZ9LNISPPJ)](https://codecov.io/gh/wingify/vwo-fme-java-sdk)\n[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0)\n\n## Overview\n\nThe **VWO Feature Management and Experimentation SDK** (VWO FME Java SDK) enables java developers to integrate feature flagging and experimentation into their applications. This SDK provides full control over feature rollout, A/B testing, and event tracking, allowing teams to manage features dynamically and gain insights into user behavior.\n\n## Requirements\n\nThe Java SDK supports:\n\n* Open JDK - 8 onwards\n* Oracle JDK - 8 onwards\n\nOur [Build](https://github.com/wingify/vwo-fme-java-sdk/actions) is successful on these Java Versions -\n\n## Installation\n\nInstall dependencies using `mvn install`\n\nAdd below Maven dependency in your project.\n\n\n```java\n\u003cdependency\u003e\n    \u003cgroupId\u003ecom.vwo.sdk\u003c/groupId\u003e\n    \u003cartifactId\u003evwo-fme-java-sdk\u003c/artifactId\u003e\n    \u003cversion\u003eLATEST\u003c/version\u003e\n\u003c/dependency\u003e\n```\n\n## Basic Usage Example\n\nThe following example demonstrates initializing the SDK with a VWO account ID and SDK key, setting a user context, checking if a feature flag is enabled, and tracking a custom event.\n ```java\n import com.vwo.VWO;\nimport com.vwo.models.user.VWOContext;\nimport com.vwo.models.user.GetFlag;\nimport com.vwo.models.user.VWOInitOptions;\nimport java.util.Map;\n\npublic class VWOExample {\n    public static void main(String[] args) {\n        // Initialize VWO SDK with your account details\n        VWOInitOptions vwoInitOptions = new VWOInitOptions();\n        vwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\"); // Replace with your SDK key\n        vwoInitOptions.setAccountId(123456); // Replace with your account ID\n\n        // Initialize VWO instance\n        VWO vwoInstance = VWO.init(vwoInitOptions);\n\n        // Create user context\n        VWOContext context = new VWOContext();\n        context.setId(\"unique_user_id\"); // Set a unique user identifier\n\n        // Check if a feature flag is enabled\n        GetFlag getFlag = vwoInstance.getFlag(\"feature_key\", context);\n        Boolean isFeatureEnabled = getFlag.isEnabled();\n        System.out.println(\"Is feature enabled? \" + isFeatureEnabled);\n\n        // Get a variable value with a default fallback\n        String variableValue = (String) getFlag.getVariable(\"feature_variable\", \"default_value\");\n        System.out.println(\"Variable value: \" + variableValue);\n\n        // Track a custom event\n        Map\u003cString, Boolean\u003e trackResponse = vwoInstance.trackEvent(\"event_name\", context);\n        System.out.println(\"Event tracked: \" + trackResponse);\n\n        // Set multiple custom attributes \n        Map\u003cString, Object\u003e attributeMap = new HashMap\u003c\u003e();\n        attributeMap.put(\"attribute-name\", \"attribute-value\");\n        vwoInstance.setAttribute(attributeMap, context);\n    }\n}\n ```\n\n## Advanced Configuration Options\n\nTo customize the SDK further, additional parameters can be passed to the `init()` API using the `VWOInitOptions` object. Here’s a table describing each option:\n\n| **Parameter**                | **Description**                                                                                                                                             | **Required** | **Type** | **Example**                     |\n| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | -------- | ------------------------------- |\n| `setAccountId`                  | VWO Account ID for authentication.                                                                                                                          | Yes          | String   | `'123456'`                      |\n| `setSdkKey`                     | SDK key corresponding to the specific environment to initialize the VWO SDK Client. You can get this key from VWO Application.                              | Yes          | String   | `'32-alpha-numeric-sdk-key'`    |\n| `setPollInterval`               | Time interval for fetching updates from VWO servers (in milliseconds).                                                                                      | No           | Number   | `60000`                         |\n| `setGatewayService`             | Configuration for integrating VWO Gateway Service. Service.                                                                                   | No           | Object   | see [Gateway](#gateway) section |\n| `setStorage`                    | Custom storage connector for persisting user decisions and campaign data. data.                                                                                   | No           | Object   | See [Storage](#storage) section |\n| `setLogger`                     | Toggle log levels for more insights or for debugging purposes. You can also customize your own transport in order to have better control over log messages. | No           | Object   | See [Logger](#logger) section   |\n| `setIntegrations`               | Callback function for integrating with third-party analytics services.                                                                                      | No           | Function | See [Integrations](#integrations) section |\n| `setIsAliasingEnabled`         | Enable user aliasing functionality. Requires gateway service to be configured.                                                                              | No           | Boolean  | see [UserAliasing](#UserAliasing) section                        |\n| `setProxyUrl`                  | Custom proxy URL for redirecting all SDK network requests (settings, tracking, etc.) through your own proxy server.                                        | No           | String   | see [Proxy](#proxy) section                        |\n\nRefer to the [official VWO documentation](https://developers.vwo.com/v2/docs/fme-java-install) for additional parameter details.\n\n### User Context\n\nThe `VWOContext` object uniquely identifies users and is crucial for consistent feature rollouts. A typical `VWOContext` includes an `id` for identifying the user, set via `setId()`. It can also include other attributes that can be used for targeting and segmentation, such as custom variables (set via `setCustomVariables()`), user agent (set via `setUserAgent()`) and IP address (set via `setIpAddress()`).\n\n#### Parameters Table\n\nThe following table explains all the parameters in the `VWOContext` object:\n\n| **Parameter**     | **Description**                                                            | **Required** | **Type** |\n| ----------------- | -------------------------------------------------------------------------- | ------------ | -------- |\n| `setId`              | Unique identifier for the user.                                            | Yes          | String   |\n| `setCustomVariables` | Custom attributes for targeting.                                           | No           | Map\u003cString, Object\u003e |\n| `setUserAgent`       | User agent string for identifying the user's browser and operating system. | No           | String   |\n| `setIpAddress`       | IP address of the user.                                                    | No           | String   |\n\n#### Example\n\n```java\nVWOContext context = new VWOContext();\ncontext.setId(\"unique_user_id\"); // Set a unique user identifier\n\n// Create the map using HashMap in Java 8 and below\nMap\u003cString, Object\u003e customVariables = new HashMap\u003c\u003e();\ncustomVariables.put(\"age\", 25);\ncustomVariables.put(\"location\", \"US\");\ncontext.setCustomVariables(customVariables);\n\ncontext.setUserAgent(\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36\");\ncontext.setIpAddress(\"1.1.1.1\");\n```\n\n### Basic Feature Flagging\n\nFeature Flags serve as the foundation for all testing, personalization, and rollout rules within FME.\nTo implement a feature flag, first use the `getFlag()` method to retrieve the flag configuration.\nThe `getFlag()` method provides a simple way to check if a feature is enabled for a specific user and access its variables. It returns a `GetFlag` object that contains methods like `isEnabled()` for checking the feature's status and `getVariable()` for retrieving any associated variables.\n\n| Parameter    | Description                                                      | Required | Type        |\n| ------------ | ---------------------------------------------------------------- | -------- | ----------- |\n| `featureKey` | Unique identifier of the feature flag                            | Yes      | String      |\n| `context`    | Object containing user identification and contextual information | Yes      | VWOContext  |\n\nExample usage:\n\n```java\nGetFlag featureFlag = vwoInstance.getFlag(\"feature_key\", context);\nBoolean isEnabled = featureFlag.isEnabled();\n\nif (isEnabled) {\n  System.out.println(\"Feature is enabled!\");\n\n  // Get and use feature variable with type safety\n  String variableValue = (String) featureFlag.getVariable('feature_variable', 'default_value');\n  System.out.println(\"Variable value: \" + variableValue);\n} else {\n  System.out.println(\"Feature is not enabled!\");\n}\n```\n\n### Custom Event Tracking\n\nFeature flags can be enhanced with connected metrics to track key performance indicators (KPIs) for your features. These metrics help measure the effectiveness of your testing rules by comparing control versus variation performance, and evaluate the impact of personalization and rollout campaigns. Use the `trackEvent()` method to track custom events like conversions, user interactions, and other important metrics:\n\n| Parameter         | Description                                                            | Required | Type        |\n| ----------------- | ---------------------------------------------------------------------- | -------- | ----------- |\n| `eventName`       | Name of the event you want to track                                    | Yes      | String      |\n| `context`         | Object containing user identification and contextual information       | Yes      | VWOContext  |\n| `eventProperties` | Additional properties/metadata associated with the event               | No       | Map\u003cString, Object\u003e |\n\nExample usage:\n\n```java\nvwoInstance.trackEvent('event_name', context, eventProperties);\n```\n\nSee [Tracking Conversions](https://developers.vwo.com/v2/docs/fme-java-metrics#usage) documentation for more information.\n\n### Pushing Attributes\n\nUser attributes provide rich contextual information about users, enabling powerful personalization. The `setAttribute()` method in VWOClient provides a simple way to associate these attributes with users in VWO for advanced segmentation. The method accepts an attribute key, value, and VWOContext object containing the user information. Here's what you need to know about the method parameters:\n\n| Parameter      | Description                                                            | Required | Type        |\n|----------------|------------------------------------------------------------------------| -------- | ----------- |\n| `attributeMap` | Multiple attributes you want to set for a user.                        | Yes      | String      |\n| `context`      | Object containing user identification and other contextual information | Yes      | VWOContext  |\n\nExample usage:\n\n```java\nMap\u003cString, Object\u003e attributeMap = new HashMap\u003c\u003e();\nattributeMap.put(\"attribute-name\", \"attribute-value\");\nvwoInstance.setAttribute(attributeMap, context);\n```\n\nSee [Pushing Attributes](https://developers.vwo.com/v2/docs/fme-java-attributes#usage) documentation for additional information.\n\n### Polling Interval Adjustment\n\nThe `setPollInterval` is an optional parameter that allows the SDK to automatically fetch and update settings from the VWO server at specified intervals. The polling interval can be configured in three ways:\n\n1. Set via SDK options: If `pollInterval` is specified in the initialization options (must be \u003e= 1000 milliseconds), that interval will be used\n2. VWO Application Settings: If configured in your VWO application settings, that interval will be used\n3. Default Fallback: If neither of the above is set, a 10 minute (600,000 milliseconds) polling interval is used\n\nSetting this parameter ensures your application always uses the latest configuration by periodically checking for and applying any updates.\n```java\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setPollInterval(60000); // Set the poll interval to 60 seconds\n\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n\n### Proxy\n\nThe `setProxyUrl` parameter allows you to redirect all SDK network calls through a custom proxy URL. 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.\n\n```java\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\n\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\nvwoInitOptions.setAccountId(123456);\nvwoInitOptions.setProxyUrl(\"http://custom.proxy.com\");\n\nVWO instance = VWO.init(vwoInitOptions);\n```\n\n### Gateway\n\nThe VWO FME Gateway Service is an optional but powerful component that enhances VWO's Feature Management and Experimentation (FME) SDKs. It acts as a critical intermediary for pre-segmentation capabilities based on user location and user agent (UA). By deploying this service within your infrastructure, you benefit from minimal latency and strengthened security for all FME operations.\n\n#### Why Use a Gateway?\n\nThe Gateway Service is required in the following scenarios:\n\n- When using pre-segmentation features based on user location or user agent.\n- For applications requiring advanced targeting capabilities.\n- It's mandatory when using any thin-client SDK (e.g., Go).\n\n#### How to Use the Gateway\n\nThe gateway can be customized by passing the `setGatewayService()` parameter in the `init` configuration.\n\n```java\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setAccountId(123456);\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\n\nMap\u003cString, Object\u003e gatewayService = new HashMap\u003c\u003e();\ngatewayService.put(\"url\", \"http://custom.gateway.com\");\nvwoInitOptions.setGatewayService(gatewayService);\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n\nRefer to the [Gateway Documentation](https://developers.vwo.com/v2/docs/gateway-service) for further details.\n\n### UserAliasing\n\nUser aliasing allows you to create consistent user experiences across different user identifiers. This is particularly useful when users can be identified by multiple IDs (e.g., anonymous ID, authenticated ID, email, etc.) and you want to maintain consistent feature flag decisions across these different identifiers.\n\n#### Prerequisites\n\nUser aliasing requires:\n\n1. **Gateway Service**: Must be configured and running. see [Gateway](#gateway) section for more details.\n2. **Aliasing Enabled**: Must be set to `true` in initialization options\n\n#### Configuration\n\nTo enable user aliasing, you need to configure both the gateway service and the aliasing flag:\n\n```java\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\n\nvwoInitOptions.setSdkKey(\"sdk-key\");\nvwoInitOptions.setAccountId(1234);\n\n// set gateway service\nMap\u003cString, Object\u003e gatewayService = new HashMap\u003c\u003e();\ngatewayService.put(\"url\", \"http://custom.gateway.com\");\nvwoInitOptions.setGatewayService(gatewayService);\n\n// set aliasing flag in vwoInitOptions\nvwoInitOptions.setIsAliasingEnabled(true);\nVWO instance = VWO.init(vwoInitOptions);\n```\n\n#### Setting User Alias\n\nUse the `setAlias()` method to create an alias relationship between a user ID and an alias ID:\n\n```java\n// Method 1: Using user ID and alias ID directly\nBoolean isAliasSet = vwoInstance.setAlias(\"user-123\", \"alias-456\");\n\n// Method 2: Using VWOContext and alias ID\nVWOContext context = new VWOContext();\ncontext.setId(\"user-123\");\nBoolean isAliasSet = vwoInstance.setAlias(context, \"alias-456\");\n```\n\n### Storage\n\nThe SDK operates in a stateless mode by default, meaning each `getFlag` call triggers a fresh evaluation of the flag against the current user context.\n\nTo optimize performance and maintain consistency, you can implement a custom storage mechanism by passing a `setStorage()` parameter during initialization. This allows you to persist feature flag decisions in your preferred database system (like Redis, MongoDB, or any other data store).\n\nKey benefits of implementing storage:\n\n- Improved performance by caching decisions\n- Consistent user experience across sessions\n- Reduced load on your application\n\nThe storage mechanism ensures that once a decision is made for a user, it remains consistent even if campaign settings are modified in the VWO Application. This is particularly useful for maintaining a stable user experience during A/B tests and feature rollouts.\n\n```java\n  import com.vwo.packages.storage.Connector;\n  import java.util.HashMap;\n  import java.util.Map;\n  public class StorageTest extends Connector {\n  \n  private final Map\u003cString, Map\u003cString, Object\u003e\u003e storage = new HashMap\u003c\u003e();\n\n    @Override\n    public void set(Map\u003cString, Object\u003e data) throws Exception {\n        String key = data.get(\"featureKey\") + \"_\" + data.get(\"userId\");\n\n        // Create a map to store the data\n        Map\u003cString, Object\u003e value = new HashMap\u003c\u003e();\n        value.put(\"rolloutKey\", data.get(\"rolloutKey\"));\n        value.put(\"rolloutId\", data.get(\"rolloutId\"));\n        value.put(\"rolloutVariationId\", data.get(\"rolloutVariationId\"));\n        value.put(\"experimentKey\", data.get(\"experimentKey\"));\n        value.put(\"experimentId\", data.get(\"experimentId\"));\n        value.put(\"experimentVariationId\", data.get(\"experimentVariationId\"));\n\n        // Store the value in the storage\n        storage.put(key, value);\n    }\n\n    @Override\n    public Object get(String featureKey, String userId) throws Exception {\n        String key = featureKey + \"_\" + userId;\n\n        // Check if the key exists in the storage\n        if (storage.containsKey(key)) {\n            return storage.get(key);\n        }\n        return null;\n    }\n  }\n  ```\n\n### Logger\n\nVWO by default logs all `ERROR` level messages to your server console.\nTo gain more control over VWO's logging behaviour, you can use the `setLogger()` parameter in the `init` configuration.\n\n| **Parameter** | **Description**                                      | **Required** | **Type** | **Default Value** |\n| ------------- |------------------------------------------------------| ------------ |---------| ----------------- |\n| `level`       | Log level to control verbosity of logs               | Yes          | String  | `ERROR`           |\n| `prefix`      | Custom prefix for log messages                       | No           | String  | `VWO-SDK`             |\n| `transport`   | Custom logger implementation for single transport    | No           | Map\u003cString, Object\u003e        | `null`            |\n| `transports`  | Custom logger implementation for multiple transports | No           | List\u003cMap\u003cString, Object\u003e\u003e       | `null`            |\n#### Example 1: Set log level to control verbosity of logs\n\n```java\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setAccountId(123456);\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\n\nMap\u003cString, Object\u003e logger = new HashMap\u003c\u003e();\nlogger.put(\"level\", \"DEBUG\");\nvwoInitOptions.setLogger(logger);\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n\n#### Example 2: Add custom prefix to log messages for easier identification\n\n```java\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setAccountId(123456);\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\n\nMap\u003cString, Object\u003e logger = new HashMap\u003c\u003e();\nlogger.put(\"level\", \"DEBUG\");\nlogger.put(\"prefix\", \"CUSTOM LOG PREFIX\");\nvwoInitOptions.setLogger(logger);\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n\n#### Example 3: Implement custom transport to handle logs your way\n\nThe `transport` parameter allows you to implement custom logging behavior by providing your own logging functions. You can define handlers for different log levels (`debug`, `info`, `warn`, `error`, `trace`) to process log messages according to your needs.\n\nFor example, you could:\n\n- Send logs to a third-party logging service\n- Write logs to a file\n- Format log messages differently\n- Filter or transform log messages\n- Route different log levels to different destinations\n\nThe transport object should implement handlers for the log levels you want to customize. Each handler receives the log message as a parameter.\n\nFor single transport you can use the `transport` parameter. For example:\n\n```java\nimport com.vwo.interfaces.logger.LogTransport;\nimport com.vwo.packages.logger.enums.LogLevelEnum;\n\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setAccountId(123456);\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\n\nMap\u003cString, Object\u003e logger = new HashMap\u003c\u003e();\nLogTransport logTransport = (level, message) -\u003e {\n    // your custom logging logic here\n};\nlogger.put(\"transport\", new HashMap\u003cString, Object\u003e() {{\n    put(\"level\", LogLevelEnum.DEBUG);\n    put(\"log\", logTransport);\n}});\n\nvwoInitOptions.setLogger(logger);\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n\nFor multiple transports you can use the `transports` parameter. For example:\n```java\nimport com.vwo.interfaces.logger.LogTransport;\nimport com.vwo.packages.logger.enums.LogLevelEnum;\n\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setAccountId(123456);\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\n\nMap\u003cString, Object\u003e logger = new HashMap\u003c\u003e();\nList\u003cMap\u003cString, Object\u003e\u003e transports = new ArrayList\u003c\u003e();\nLogTransport errorTransport = (level, message) -\u003e {\n    // your custom logging logic here\n};\nLogTransport infoTransport = (level, message) -\u003e {\n    // your custom logging logic here\n};\n\ntransports.add(new HashMap\u003cString, Object\u003e() {{\n    put(\"level\", LogLevelEnum.INFO);\n    put(\"log\", infoTransport);\n}});\ntransports.add(new HashMap\u003cString, Object\u003e() {{\n    put(\"level\", LogLevelEnum.ERROR);\n    put(\"log\", errorTransport);\n}});\nlogger.put(\"transports\", transports);\n\nvwoInitOptions.setLogger(logger);\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n### Integrations\nVWO FME 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 VWO-specific properties and can forward them to any third-party tool of your choice.\n\n```java\nimport com.vwo.interfaces.integration.IntegrationCallback;\n\nIntegrationCallback integrations = properties -\u003e {\n    // your function definition \n};\n\nVWOInitOptions vwoInitOptions = new VWOInitOptions();\nvwoInitOptions.setSdkKey(\"32-alpha-numeric-sdk-key\");\nvwoInitOptions.setAccountId(12345);\nvwoInitOptions.setIntegrations(integrations);\n\nVWO vwoInstance = VWO.init(vwoInitOptions);\n```\n\nRefer to the [Integrations](https://developers.vwo.com/v2/docs/fme-java-integrations) documentation for more information.\n\n### Version History\n\nThe version history tracks changes, improvements, and bug fixes in each version. For a full history, see the [CHANGELOG.md](https://github.com/wingify/vwo-fme-java-sdk/blob/master/CHANGELOG.md).\n\n## Contributing\n\nWe welcome contributions to improve this SDK! Please read our [contributing guidelines](https://github.com/wingify/vwo-fme-java-sdk/blob/master/CONTRIBUTING.md) before submitting a PR.\n\n## Code of Conduct\n\nOur [Code of Conduct](https://github.com/wingify/vwo-fme-java-sdk/blob/master/CODE_OF_CONDUCT.md) outlines expectations for all contributors and maintainers.\n\n## License\n\n[Apache License, Version 2.0](https://github.com/wingify/vwo-fme-java-sdk/blob/master/LICENSE)\n\nCopyright 2024-2025 Wingify Software Pvt. Ltd.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fwingify%2Fvwo-fme-java-sdk","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fwingify%2Fvwo-fme-java-sdk","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fwingify%2Fvwo-fme-java-sdk/lists"}