Function bodies 269 total

    private RuleSet parseRuleSet(JSONObject json) {
        if (json == null) {
            return new RuleSet(Collections.emptyList(), Collections.emptyList());
        }

        // Parse variants
        List<Variant> variants = new ArrayList<>();
        JSONArray variantsJson = json.optJSONArray("variants");
        if (variantsJson != null) {
            for (int i = 0; i < variantsJson.length(); i++) {
                variants.add(parseVariant(variantsJson.getJSONObject(i)));
            }
        }

        // Sort variants by key for consistent ordering
        variants.sort(Comparator.comparing(Variant::getKey));

        // Parse rollouts
        List<Rollout> rollouts = new ArrayList<>();
        JSONArray rolloutsJson = json.optJSONArray("rollout");
        if (rolloutsJson != null) {
            for (int i = 0; i < rolloutsJson.length(); i++) {
                rollouts.add(parseRollout(rolloutsJson.getJSONObject(i)));
            }
        }

        // Parse test user ov

    private Variant parseVariant(JSONObject json) {
        String key = json.optString("key", "");
        Object value = json.opt("value");
        boolean isControl = json.optBoolean("is_control", false);
        float split = (float) json.optDouble("split", 0.0);

        return new Variant(key, value, isControl, split);
    }

    private Rollout parseRollout(JSONObject json) {
        float rolloutPercentage = (float) json.optDouble("rollout_percentage", 0.0);
        VariantOverride variantOverride = null;

        if (json.has("variant_override") && !json.isNull("variant_override")) {
            JSONObject variantObj = json.optJSONObject("variant_override");
            if (variantObj != null) {
                String key = variantObj.optString("key", "");
                if (!key.isEmpty()) {
                    variantOverride = new VariantOverride(key);
                }
            }
        }

        // Parse legacy runtime evaluation (simple key-value format)
        Map<String, Object> legacyRuntimeEval = null;
        JSONObject legacyRuntimeEvalJson = json.optJSONObject("runtime_evaluation_definition");
        if (legacyRuntimeEvalJson != null) {
            legacyRuntimeEval = new HashMap<>();
            for (String key : legacyRuntimeEvalJson.keySet()) {
                legacyRuntimeEval.pu

    public <T> SelectedVariant<T> getVariant(String flagKey, SelectedVariant<T> fallback, Map<String, Object> context, boolean reportExposure) {
        long startTime = System.currentTimeMillis();

        try {
            // Get flag definition
            Map<String, ExperimentationFlag> definitions = flagDefinitions.get();
            ExperimentationFlag flag = definitions.get(flagKey);

            if (flag == null) {
                logger.log(Level.WARNING, "Flag not found: " + flagKey);
                return fallback;
            }

            // Extract context value
            String contextProperty = flag.getContext();
            Object contextValueObj = context.get(contextProperty);
            if (contextValueObj == null) {
                logger.log(Level.WARNING, "Variant assignment key property '" + contextProperty + "' not found for flag: " + flagKey);
                return fallback;
            }
            String contextValue = contextValueObj.toString();

   

    private <T> SelectedVariant<T> buildResult(Variant variant, ExperimentationFlag flag, boolean isQaTester,
                                                String flagKey, Map<String, Object> context,
                                                long startTime, boolean reportExposure) {
        SelectedVariant<T> result = new SelectedVariant<>(
            variant.getKey(),
            (T) variant.getValue(),
            flag.getExperimentId(),
            flag.getIsExperimentActive(),
            isQaTester
        );
        if (reportExposure) {
            trackLocalExposure(context, flagKey, variant.getKey(), System.currentTimeMillis() - startTime,
                    flag.getExperimentId(), flag.getIsExperimentActive(), isQaTester);
        }
        return result;
    }

    private boolean matchesRuntimeConditions(Rollout rollout, Map<String,Object> context) {
        Map<String, Object> customProperties = getCustomProperties(context);
        return JsonLogicEngine.evaluate(rollout.getRuntimeEvaluationRule(), customProperties);
    }

    private boolean matchesLegacyRuntimeConditions(Rollout rollout, Map<String, Object> context) {
        Map<String, Object> customProperties = getCustomProperties(context);
        if (customProperties == null) {
            return false;
        }

        Map<String, Object> runtimeEval = rollout.getLegacyRuntimeEvaluationDefinition();
        for (Map.Entry<String, Object> entry : runtimeEval.entrySet()) {
            String key = entry.getKey();
            Object expectedValue = entry.getValue();
            Object actualValue = customProperties.get(key);

            // Case-insensitive comparison for strings
            if (!valuesEqual(expectedValue, actualValue)) {
                return false;
            }
        }

        return true;
    }

    private Map<String, Object> getCustomProperties(Map<String, Object> context) {
        Object customPropsObj = context.get("custom_properties");
        if (customPropsObj instanceof Map) {
            return (Map<String, Object>) customPropsObj;
        }
        return null;
    }

    private boolean valuesEqual(Object expected, Object actual) {
        if (expected == null || actual == null) {
            return expected == actual;
        }

        // Case-insensitive comparison for strings
        if (expected instanceof String && actual instanceof String) {
            return ((String) expected).equalsIgnoreCase((String) actual);
        }

        return expected.equals(actual);
    }

    private Variant findVariantByKey(List<Variant> variants, String key) {
        for (Variant variant : variants) {
            if (variant.getKey().equals(key)) {
                return variant;
            }
        }
        return null;
    }

    private List<Variant> applyVariantSplitOverrides(List<Variant> variants, Map<String, Float> variantSplits) {
        List<Variant> result = new ArrayList<>(variants.size());

        for (Variant variant : variants) {
            if (variantSplits.containsKey(variant.getKey())) {
                // Create new variant with overridden split value
                float overriddenSplit = variantSplits.get(variant.getKey());
                Variant updatedVariant = new Variant(
                    variant.getKey(),
                    variant.getValue(),
                    variant.isControl(),
                    overriddenSplit
                );
                result.add(updatedVariant);
            } else {
                // Keep original variant with its original split
                result.add(variant);
            }
        }

        return result;
    }

    private Variant selectVariantBySplit(List<Variant> variants, float hash, Rollout rollout) {
        // Apply variant split overrides if the rollout specifies them
        List<Variant> variantsToUse = variants;
        if (rollout != null && rollout.hasVariantSplits()) {
            variantsToUse = applyVariantSplitOverrides(variants, rollout.getVariantSplits());
        }

        // Select variant using cumulative split percentages
        float cumulative = 0.0f;
        for (Variant variant : variantsToUse) {
            cumulative += variant.getSplit();
            if (hash < cumulative) {
                return variant;
            }
        }

        // If no variant selected (due to rounding), return last variant
        return variantsToUse.isEmpty() ? null : variantsToUse.get(variantsToUse.size() - 1);
    }

    protected float calculateRolloutHash(String contextValue, String flagKey,
                                        String hashSalt, int rolloutIndex) {
        if (hashSalt != null && !hashSalt.isEmpty()) {
            return HashUtils.normalizedHash(contextValue + flagKey, hashSalt + rolloutIndex);
        } else {
            return HashUtils.normalizedHash(contextValue + flagKey, "rollout");
        }
    }

    protected float calculateVariantHash(String contextValue, String flagKey, String hashSalt) {
        if (hashSalt != null && !hashSalt.isEmpty()) {
            return HashUtils.normalizedHash(contextValue + flagKey, hashSalt + "variant");
        } else {
            return HashUtils.normalizedHash(contextValue + flagKey, "variant");
        }
    }

    public List<SelectedVariant<Object>> getAllVariants(Map<String, Object> context, boolean reportExposure) {
        List<SelectedVariant<Object>> results = new ArrayList<>();
        Map<String, ExperimentationFlag> definitions = flagDefinitions.get();

        for (ExperimentationFlag flag : definitions.values()) {
            SelectedVariant<Object> fallback = new SelectedVariant<>(null);
            SelectedVariant<Object> result = getVariant(flag.getKey(), fallback, context, reportExposure);

            // Only include successfully selected variants (not fallbacks)
            if (result.isSuccess()) {
                results.add(result);
            }
        }

        return results;
    }

    private void trackLocalExposure(Map<String, Object> context, String flagKey, String variantKey, long latencyMs, UUID experimentId, Boolean isExperimentActive, Boolean isQaTester) {
        if (eventSender == null) {
            return;
        }

        Object distinctIdObj = context.get("distinct_id");
        if (distinctIdObj == null) {
            return;
        }

        trackExposure(distinctIdObj.toString(), flagKey, variantKey, "local", properties -> {
            properties.put("Variant fetch latency (ms)", latencyMs);
        }, experimentId, isExperimentActive, isQaTester);
    }

    protected Logger getLogger() {
        return logger;
    }

    public void close() {
        if (closed.compareAndSet(false, true)) {
            stopPollingForDefinitions();
        }
    }

    public void shutdown() {
        close();
    }

    public RemoteFlagsProvider(RemoteFlagsConfig config, String sdkVersion, EventSender eventSender) {
        super(config.getProjectToken(), config, sdkVersion, eventSender);
    }

    public <T> SelectedVariant<T> getVariant(String flagKey, SelectedVariant<T> fallback, Map<String, Object> context, boolean reportExposure) {
        String startTime = getCurrentIso8601Timestamp();

        try {
            String endpoint = buildFlagsUrl(flagKey, context);

            String response = httpGet(endpoint);

            JSONObject root = new JSONObject(response);
            JSONObject flags = root.optJSONObject("flags");

            if (flags == null || !flags.has(flagKey)) {
                logger.log(Level.WARNING, "Flag not found in response: " + flagKey);
                return fallback;
            }

            JSONObject flagData = flags.getJSONObject(flagKey);
            String variantKey = flagData.optString("variant_key", null);
            Object variantValue = flagData.opt("variant_value");

            if (variantKey == null) {
                return fallback;
            }

            // Parse experiment metadata
            UUID experimentId = n

    private String getCurrentIso8601Timestamp() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
        return sdf.format(new Date());
    }

    private void trackRemoteExposure(Map<String, Object> context, String flagKey, String variantKey, String startTime, String completeTime, UUID experimentId, Boolean isExperimentActive, Boolean isQaTester) {
        if (eventSender == null) {
            return;
        }

        Object distinctIdObj = context.get("distinct_id");
        if (distinctIdObj == null) {
            return;
        }

        trackExposure(distinctIdObj.toString(), flagKey, variantKey, "remote", properties -> {
            properties.put("Variant fetch start time", startTime);
            properties.put("Variant fetch complete time", completeTime);
        }, experimentId, isExperimentActive, isQaTester);
    }

    protected Logger getLogger() {
        return logger;
    }

public final class HashUtils {

    /**
     * FNV-1a 64-bit offset basis constant.
     */
    private static final long FNV_OFFSET_BASIS_64 = 0xcbf29ce484222325L;

    /**
     * FNV-1a 64-bit prime constant.
     */
    private static final long FNV_PRIME_64 = 0x100000001b3L;

    // Private constructor to prevent instantiation
    private HashUtils() {
        throw new AssertionError("HashUtils should not be instantiated");
    }

    /**
     * Generates a normalized hash value in the range [0.0, 1.0) using the FNV-1a algorithm.
     *
     * @param key the input string to hash (typically user identifier + flag key)
     * @param salt the salt to append to the input (e.g., "rollout" or "variant")
     * @return a float value in the range [0.0, 1.0)
     * @throws IllegalArgumentException if key or salt is null
     */
    public static float normalizedHash(String key, String salt) {
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null");
 

    private HashUtils() {
        throw new AssertionError("HashUtils should not be instantiated");
    }

    public static float normalizedHash(String key, String salt) {
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null");
        }
        if (salt == null) {
            throw new IllegalArgumentException("Salt cannot be null");
        }

        // Combine key and salt
        String combined = key + salt;
        byte[] bytes = combined.getBytes(StandardCharsets.UTF_8);

        // FNV-1a 64-bit hash
        long hash = FNV_OFFSET_BASIS_64;
        for (byte b : bytes) {
            // XOR with byte (converting to unsigned)
            hash ^= (b & 0xff);
            // Multiply by FNV prime
            hash *= FNV_PRIME_64;
        }

        // Normalize to [0.0, 1.0) matching Python's approach
        // Use Long.remainderUnsigned to handle negative values correctly
        return (float) (Long.remainderUnsigned(hash, 100) / 100.0);
    }

    public static float rolloutHash(String input) {
        return normalizedHash(input, "rollout");
    }

    public static float variantHash(String input) {
        return normalizedHash(input, "variant");
    }

public class JsonCaseDesensitizer {
    public static Object lowercaseLeafNodes(Object object) {
        if (object == null) {
            return null;
        }
        else if (object instanceof String){
            return ((String) object).toLowerCase();
        } else if (object instanceof org.json.JSONObject) {
            org.json.JSONObject jsonObject = (org.json.JSONObject) object;
            org.json.JSONObject result = new org.json.JSONObject();
            for (String key : jsonObject.keySet()) {
                result.put(key, lowercaseLeafNodes(jsonObject.get(key)));
            }
            return result;
        } else if (object instanceof org.json.JSONArray) {
            org.json.JSONArray jsonArray = (org.json.JSONArray) object;
            org.json.JSONArray result = new org.json.JSONArray();
            for (int i = 0; i < jsonArray.length(); i++) {
                result.put(lowercaseLeafNodes(jsonArray.get(i)));
            }
            return result;
        

    public static Object lowercaseLeafNodes(Object object) {
        if (object == null) {
            return null;
        }
        else if (object instanceof String){
            return ((String) object).toLowerCase();
        } else if (object instanceof org.json.JSONObject) {
            org.json.JSONObject jsonObject = (org.json.JSONObject) object;
            org.json.JSONObject result = new org.json.JSONObject();
            for (String key : jsonObject.keySet()) {
                result.put(key, lowercaseLeafNodes(jsonObject.get(key)));
            }
            return result;
        } else if (object instanceof org.json.JSONArray) {
            org.json.JSONArray jsonArray = (org.json.JSONArray) object;
            org.json.JSONArray result = new org.json.JSONArray();
            for (int i = 0; i < jsonArray.length(); i++) {
                result.put(lowercaseLeafNodes(jsonArray.get(i)));
            }
            return result;
        } else {
            return object;

    public static Object lowercaseAllNodes(Object object) {
        if (object == null) {
            return null;
        }
        else if (object instanceof String){
            return ((String) object).toLowerCase();
        } else if (object instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) object;
            Map<Object, Object> result = new java.util.HashMap<>();
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                Object lowerKey = entry.getKey() instanceof String
                    ? ((String) entry.getKey()).toLowerCase()
                    : entry.getKey();
                result.put(lowerKey, lowercaseAllNodes(entry.getValue()));
            }
            return result;
        } else if( object instanceof Iterable) {
            Iterable<?> iterable = (Iterable<?>) object;
            java.util.List<Object> result = new java.util.ArrayList<>();
            for (Object item : iterable) {
                result.add(lowercaseAllNodes(item));
  

public class JsonLogicEngine {
    private static final java.util.logging.Logger logger = java.util.logging.Logger.getLogger(JsonLogicEngine.class.getName());

    private static final JsonLogic jsonLogic = new JsonLogic();

    public static boolean evaluate(JSONObject rule, Map<String, Object> data) {
        if (data == null) {
            data = new HashMap<>();
        }
        Map<String, Object> lowercasedData = (Map<String, Object>) JsonCaseDesensitizer.lowercaseAllNodes(data);
        try {
            String ruleJson = JsonCaseDesensitizer.lowercaseLeafNodes(rule).toString();
            logger.log(Level.FINE, () -> "Evaluating JsonLogic rule: " + ruleJson + " with data: " + lowercasedData.toString());
            Object result = jsonLogic.apply(ruleJson, lowercasedData);
            return JsonLogic.truthy(result);
        } catch (Exception e) {
            logger.log(Level.WARNING, "Error evaluating runtime rule", e);
            return false;
        }
    } 
}

    public static boolean evaluate(JSONObject rule, Map<String, Object> data) {
        if (data == null) {
            data = new HashMap<>();
        }
        Map<String, Object> lowercasedData = (Map<String, Object>) JsonCaseDesensitizer.lowercaseAllNodes(data);
        try {
            String ruleJson = JsonCaseDesensitizer.lowercaseLeafNodes(rule).toString();
            logger.log(Level.FINE, () -> "Evaluating JsonLogic rule: " + ruleJson + " with data: " + lowercasedData.toString());
            Object result = jsonLogic.apply(ruleJson, lowercasedData);
            return JsonLogic.truthy(result);
        } catch (Exception e) {
            logger.log(Level.WARNING, "Error evaluating runtime rule", e);
            return false;
        }
    } 

public final class TraceparentUtil {

    /**
     * Private constructor to prevent instantiation.
     */
    private TraceparentUtil() {
        throw new AssertionError("TraceparentUtil should not be instantiated");
    }

    /**
     * Generates a W3C traceparent header value.
     * <p>
     * Format: 00-{trace_id}-{span_id}-01
     * Uses two separate UUIDs with dashes removed - one for trace_id (32 chars)
     * and one for span_id (16 chars).
     * </p>
     *
     * @return a traceparent header value
     */
    public static String generateTraceparent() {
        String traceId = UUID.randomUUID().toString().replace("-", "");
        String spanId = UUID.randomUUID().toString().replace("-", "").substring(0, 16);
        return "00-" + traceId + "-" + spanId + "-01";
    }
}

    private TraceparentUtil() {
        throw new AssertionError("TraceparentUtil should not be instantiated");
    }

    public static String generateTraceparent() {
        String traceId = UUID.randomUUID().toString().replace("-", "");
        String spanId = UUID.randomUUID().toString().replace("-", "").substring(0, 16);
        return "00-" + traceId + "-" + spanId + "-01";
    }

public class VersionUtil {
    private static final Logger logger = Logger.getLogger(VersionUtil.class.getName());
    private static final String VERSION_FILE = "mixpanel-version.properties";
    private static final String VERSION_KEY = "version";
    private static final String UNKNOWN_VERSION = "unknown";

    private static String cachedVersion = null;

    private VersionUtil() {
        // Utility class - prevent instantiation
    }

    /**
     * Gets the SDK version.
     * <p>
     * The version is loaded from the properties file on first access and cached.
     * Returns "unknown" if the version cannot be determined (e.g., running in IDE without build).
     * </p>
     *
     * @return the SDK version string
     */
    public static String getVersion() {
        if (cachedVersion == null) {
            cachedVersion = loadVersion();
        }
        return cachedVersion;
    }

    /**
     * Loads the version from the properties file.
     */
    private static String l

    private VersionUtil() {
        // Utility class - prevent instantiation
    }

    public static String getVersion() {
        if (cachedVersion == null) {
            cachedVersion = loadVersion();
        }
        return cachedVersion;
    }

    private static String loadVersion() {
        try (InputStream input = VersionUtil.class.getClassLoader().getResourceAsStream(VERSION_FILE)) {
            if (input == null) {
                logger.log(Level.WARNING, "Version file not found: " + VERSION_FILE + " (using fallback version)");
                return UNKNOWN_VERSION;
            }

            Properties props = new Properties();
            props.load(input);

            String version = props.getProperty(VERSION_KEY);
            if (version == null || version.isEmpty()) {
                logger.log(Level.WARNING, "Version property not found in " + VERSION_FILE);
                return UNKNOWN_VERSION;
            }

            return version;
        } catch (IOException e) {
            logger.log(Level.WARNING, "Failed to load version from " + VERSION_FILE, e);
            return UNKNOWN_VERSION;
        }
    }

public class OrgJsonSerializer implements JsonSerializer {

    @Override
    public String serializeArray(List<JSONObject> messages) {
        if (messages == null || messages.isEmpty()) {
            return "[]";
        }

        JSONArray array = new JSONArray();
        for (JSONObject message : messages) {
            array.put(message);
        }
        return array.toString();
    }
}

    public String serializeArray(List<JSONObject> messages) {
        if (messages == null || messages.isEmpty()) {
            return "[]";
        }

        JSONArray array = new JSONArray();
        for (JSONObject message : messages) {
            array.put(message);
        }
        return array.toString();
    }

    public MessageBuilder(String token) {
        mToken = token;
    }

    public JSONObject event(String distinctId, String eventName, JSONObject properties) {
        long time = System.currentTimeMillis();

        // Nothing below should EVER throw a JSONException.
        try {
            JSONObject dataObj = new JSONObject();
            dataObj.put("event", eventName);

            JSONObject propertiesObj = null;
            if (properties == null) {
                propertiesObj = new JSONObject();
            }
            else {
                propertiesObj = new JSONObject(properties.toString());
            }

            if (! propertiesObj.has("token")) propertiesObj.put("token", mToken);
            if (! propertiesObj.has("time")) propertiesObj.put("time", time);
            if (! propertiesObj.has("mp_lib")) propertiesObj.put("mp_lib", "jdk");

            if (distinctId != null)
                propertiesObj.put("distinct_id", distinctId);

            dataObj.put("properties", propertiesObj);

            JSONObject envelope = new JS

    public JSONObject importEvent(String distinctId, String eventName, JSONObject properties) {
        long time = System.currentTimeMillis();
        
        // Nothing below should EVER throw a JSONException.
        try {
            JSONObject dataObj = new JSONObject();
            dataObj.put("event", eventName);

            JSONObject propertiesObj = null;
            if (properties == null) {
                propertiesObj = new JSONObject();
            }
            else {
                propertiesObj = new JSONObject(properties.toString());
            }
            // no need to add $import true property as this is added by the backend for any event imported.
            if (! propertiesObj.has("token")) propertiesObj.put("token", mToken);
            
            // Set default time to current time if not provided
            if (! propertiesObj.has("time")) propertiesObj.put("time", time);
            
            // Generate default $insert_id if not provided (to prev

    public JSONObject set(String distinctId, JSONObject properties) {
        return set(distinctId, properties, null);
    }

    public JSONObject set(String distinctId, JSONObject properties, JSONObject modifiers) {
        return peopleMessage(distinctId, "$set", properties, modifiers);
    }

    public JSONObject setOnce(String distinctId, JSONObject properties) {
        return setOnce(distinctId, properties, null);
    }

    public JSONObject setOnce(String distinctId, JSONObject properties, JSONObject modifiers) {
        return peopleMessage(distinctId, "$set_once", properties, modifiers);
    }