Function bodies 269 total

    public boolean hasVariantSplits() {
        return variantSplits != null && !variantSplits.isEmpty();
    }

    public String toString() {
        return "Rollout{" +
                "rolloutPercentage=" + rolloutPercentage +
                ", legacyRuntimeEvaluationDefinition=" + legacyRuntimeEvaluationDefinition +
                ", runtimeEvaluationRule=" + runtimeEvaluationRule +
                ", variantOverride='" + variantOverride + '\'' +
                ", variantSplits=" + variantSplits +
                '}';
    }

    public JSONObject getRuntimeEvaluationRule() {
        return runtimeEvaluationRule;
    }

public final class RuleSet {
    private final List<Variant> variants;
    private final List<Rollout> rollouts;
    private final Map<String, String> testUserOverrides;

    /**
     * Creates a new RuleSet with all components.
     *
     * @param variants the list of available variants for this flag
     * @param rollouts the list of rollout rules (evaluated in order)
     * @param testUserOverrides optional map of distinct_id to variant key for test users
     */
    public RuleSet(List<Variant> variants, List<Rollout> rollouts, Map<String, String> testUserOverrides) {
        this.variants = variants != null ? Collections.unmodifiableList(variants) : Collections.emptyList();
        this.rollouts = rollouts != null ? Collections.unmodifiableList(rollouts) : Collections.emptyList();
        this.testUserOverrides = testUserOverrides != null
            ? Collections.unmodifiableMap(testUserOverrides)
            : null;
    }

    /**
     * Creates a new RuleSet without test user 

    public RuleSet(List<Variant> variants, List<Rollout> rollouts, Map<String, String> testUserOverrides) {
        this.variants = variants != null ? Collections.unmodifiableList(variants) : Collections.emptyList();
        this.rollouts = rollouts != null ? Collections.unmodifiableList(rollouts) : Collections.emptyList();
        this.testUserOverrides = testUserOverrides != null
            ? Collections.unmodifiableMap(testUserOverrides)
            : null;
    }

    public RuleSet(List<Variant> variants, List<Rollout> rollouts) {
        this(variants, rollouts, null);
    }

    public List<Variant> getVariants() {
        return variants;
    }

    public List<Rollout> getRollouts() {
        return rollouts;
    }

    public Map<String, String> getTestUserOverrides() {
        return testUserOverrides;
    }

    public boolean hasTestUserOverrides() {
        return testUserOverrides != null && !testUserOverrides.isEmpty();
    }

    public String toString() {
        return "RuleSet{" +
                "variants=" + variants +
                ", rollouts=" + rollouts +
                ", testUserOverrides=" + testUserOverrides +
                '}';
    }

public final class SelectedVariant<T> {
    private final String variantKey;
    private final T variantValue;
    private final UUID experimentId;
    private final Boolean isExperimentActive;
    private final Boolean isQaTester;

    /**
     * Creates a SelectedVariant with only a value (key is null).
     * This is typically used for fallback responses.
     *
     * @param variantValue the fallback value
     */
    public SelectedVariant(T variantValue) {
        this(null, variantValue, null, null, null);
    }

    /**
     * Creates a new SelectedVariant with experimentation metadata.
     *
     * @param variantKey the key of the selected variant (may be null for fallback)
     * @param variantValue the value of the selected variant (may be null for fallback)
     * @param experimentId the experiment ID (may be null)
     * @param isExperimentActive whether the experiment is active (may be null)
     * @param isQaTester whether the user is a QA tester (may be null)
     */
 

    public SelectedVariant(T variantValue) {
        this(null, variantValue, null, null, null);
    }

    public SelectedVariant(String variantKey, T variantValue, UUID experimentId, Boolean isExperimentActive, Boolean isQaTester) {
        this.variantKey = variantKey;
        this.variantValue = variantValue;
        this.experimentId = experimentId;
        this.isExperimentActive = isExperimentActive;
        this.isQaTester = isQaTester;
    }

    public String getVariantKey() {
        return variantKey;
    }

    public T getVariantValue() {
        return variantValue;
    }

    public UUID getExperimentId() {
        return experimentId;
    }

    public Boolean getIsExperimentActive() {
        return isExperimentActive;
    }

    public Boolean getIsQaTester() {
        return isQaTester;
    }

    public boolean isSuccess() {
        return variantKey != null;
    }

    public boolean isFallback() {
        return variantKey == null;
    }

    public String toString() {
        return "SelectedVariant{" +
                "variantKey='" + variantKey + '\'' +
                ", variantValue=" + variantValue +
                ", experimentId=" + experimentId +
                ", isExperimentActive=" + isExperimentActive +
                ", isQaTester=" + isQaTester +
                '}';
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        SelectedVariant<?> that = (SelectedVariant<?>) o;

        if (variantKey != null ? !variantKey.equals(that.variantKey) : that.variantKey != null) return false;
        if (variantValue != null ? !variantValue.equals(that.variantValue) : that.variantValue != null) return false;
        if (experimentId != null ? !experimentId.equals(that.experimentId) : that.experimentId != null) return false;
        if (isExperimentActive != null ? !isExperimentActive.equals(that.isExperimentActive) : that.isExperimentActive != null) return false;
        return isQaTester != null ? isQaTester.equals(that.isQaTester) : that.isQaTester == null;
    }

public final class Variant {
    private final String key;
    private final Object value;
    private final boolean isControl;
    private final float split;

    /**
     * Creates a new Variant.
     *
     * @param key the unique identifier for this variant
     * @param value the value associated with this variant (can be boolean, string, number, or JSON object)
     * @param isControl whether this variant is the control variant
     * @param split the percentage split allocation for this variant (0.0-1.0)
     */
    public Variant(String key, Object value, boolean isControl, float split) {
        this.key = key;
        this.value = value;
        this.isControl = isControl;
        this.split = split;
    }

    /**
     * @return the unique identifier for this variant
     */
    public String getKey() {
        return key;
    }

    /**
     * @return the value associated with this variant
     */
    public Object getValue() {
        return value;
    }

    /**
     * @r

    public Variant(String key, Object value, boolean isControl, float split) {
        this.key = key;
        this.value = value;
        this.isControl = isControl;
        this.split = split;
    }

    public String getKey() {
        return key;
    }

    public Object getValue() {
        return value;
    }

    public boolean isControl() {
        return isControl;
    }

    public float getSplit() {
        return split;
    }

    public String toString() {
        return "Variant{" +
                "key='" + key + '\'' +
                ", value=" + value +
                ", isControl=" + isControl +
                ", split=" + split +
                '}';
    }

public final class VariantOverride {
    private final String key;

    /**
     * Creates a new VariantOverride.
     *
     * @param key the variant key to force selection of
     */
    public VariantOverride(String key) {
        this.key = key;
    }

    /**
     * @return the variant key
     */
    public String getKey() {
        return key;
    }

    @Override
    public String toString() {
        return "VariantOverride{" +
                "key='" + key + '\'' +
                '}';
    }
}

    public VariantOverride(String key) {
        this.key = key;
    }

    public String getKey() {
        return key;
    }

    public String toString() {
        return "VariantOverride{" +
                "key='" + key + '\'' +
                '}';
    }

public abstract class BaseFlagsProvider<C extends BaseFlagsConfig> {
    protected static final int BUFFER_SIZE = 4096;

    protected final String projectToken;
    protected final C config;
    protected final String sdkVersion;
    protected final EventSender eventSender;

    /**
     * Creates a new BaseFlagsProvider.
     *
     * @param projectToken the Mixpanel project token
     * @param config the flags configuration
     * @param sdkVersion the SDK version string
     * @param eventSender the EventSender implementation for tracking exposure events
     */
    protected BaseFlagsProvider(String projectToken, C config, String sdkVersion, EventSender eventSender) {
        this.projectToken = projectToken;
        this.config = config;
        this.sdkVersion = sdkVersion;
        this.eventSender = eventSender;
    }

    // #region HTTP Methods

    /**
     * Performs an HTTP GET request with Basic Auth.
     * <p>
     * This method is protected to allow test subclasses to 

    protected BaseFlagsProvider(String projectToken, C config, String sdkVersion, EventSender eventSender) {
        this.projectToken = projectToken;
        this.config = config;
        this.sdkVersion = sdkVersion;
        this.eventSender = eventSender;
    }

    protected String httpGet(String urlString) throws IOException {
        URL url = new URL(urlString);
        URLConnection conn = url.openConnection();
        conn.setConnectTimeout(config.getRequestTimeoutSeconds() * 1000);
        conn.setReadTimeout(config.getRequestTimeoutSeconds() * 1000);

        // Set Basic Auth header (token as username, empty password)
        String auth = projectToken + ":";
        String encodedAuth = java.util.Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.UTF_8));
        conn.setRequestProperty("Authorization", "Basic " + encodedAuth);

        // Set custom headers
        conn.setRequestProperty("X-Scheme", "https");
        conn.setRequestProperty("X-Forwarded-Proto", "https");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("traceparent", TraceparentUtil.generateTraceparent());

        InputStream responseStream = null;
        try {
            responseStream = conn.ge

    protected String readStream(InputStream in) throws IOException {
        StringBuilder out = new StringBuilder();
        InputStreamReader reader = new InputStreamReader(in, StandardCharsets.UTF_8);

        char[] buffer = new char[BUFFER_SIZE];
        int count;
        while ((count = reader.read(buffer)) != -1) {
            out.append(buffer, 0, count);
        }

        return out.toString();
    }

    public <T> SelectedVariant<T> getVariant(String flagKey, SelectedVariant<T> fallback, Map<String, Object> context) {
        return getVariant(flagKey, fallback, context, true);
    }

    public <T> T getVariantValue(String flagKey, T fallbackValue, Map<String, Object> context) {
        SelectedVariant<T> fallback = new SelectedVariant<>(fallbackValue);
        SelectedVariant<T> result = getVariant(flagKey, fallback, context, true);
        return result.getVariantValue();
    }

    public boolean isEnabled(String flagKey, Map<String, Object> context) {
        SelectedVariant<Object> result = getVariant(flagKey, new SelectedVariant<>(false), context, true);
        Object value = result.getVariantValue();

        return value instanceof Boolean && (Boolean) value;
    }

    protected void trackExposure(String distinctId, String flagKey, String variantKey,
                                 String evaluationMode, Consumer<JSONObject> addTimingProperties,
                                 UUID experimentId, Boolean isExperimentActive, Boolean isQaTester) {
        try {
            JSONObject properties = new JSONObject();
            properties.put("Experiment name", flagKey);
            properties.put("Variant name", variantKey);
            properties.put("$experiment_type", "feature_flag");
            properties.put("Flag evaluation mode", evaluationMode);

            // Add experiment metadata
            if (experimentId != null) {
                properties.put("$experiment_id", experimentId.toString());
            }
            if (isExperimentActive != null) {
                properties.put("$is_experiment_active", isExperimentActive);
            }
            if (isQaTester != null) {
                properties.put("$is_qa_tester", isQaTeste

    public void shutdown() {
        // No-op by default
    }

    public LocalFlagsProvider(LocalFlagsConfig config, String sdkVersion, EventSender eventSender) {
        super(config.getProjectToken(), config, sdkVersion, eventSender);

        this.flagDefinitions = new AtomicReference<>(new HashMap<>());
        this.ready = new AtomicBoolean(false);
        this.closed = new AtomicBoolean(false);
    }

    public void startPollingForDefinitions() {
        if (closed.get()) {
            logger.log(Level.WARNING, "Cannot start polling: provider is closed");
            return;
        }

        // Initial fetch
        fetchDefinitions();

        // Start background polling if enabled
        if (config.isEnablePolling()) {
            pollingExecutor = Executors.newSingleThreadScheduledExecutor(r -> {
                Thread t = new Thread(r, "mixpanel-flags-poller");
                t.setDaemon(true);
                return t;
            });

            pollingExecutor.scheduleAtFixedRate(
                this::fetchDefinitions,
                config.getPollingIntervalSeconds(),
                config.getPollingIntervalSeconds(),
                TimeUnit.SECONDS
            );

            logger.log(Level.INFO, "Started polling for flag definitions every " + config.getPollingIntervalSeconds() + " seconds");
        }
    }

    public void stopPollingForDefinitions() {
        if (pollingExecutor != null) {
            pollingExecutor.shutdown();
            try {
                if (!pollingExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                    pollingExecutor.shutdownNow();
                }
            } catch (InterruptedException e) {
                pollingExecutor.shutdownNow();
                Thread.currentThread().interrupt();
            }
            pollingExecutor = null;
        }
    }

    public boolean areFlagsReady() {
        return ready.get();
    }

    private void fetchDefinitions() {
        try {
            String endpoint = buildDefinitionsUrl();
            String response = httpGet(endpoint);

            Map<String, ExperimentationFlag> newDefinitions = parseDefinitions(response);
            flagDefinitions.set(newDefinitions);
            ready.set(true);

            logger.log(Level.FINE, "Successfully fetched " + newDefinitions.size() + " flag definitions");
        } catch (Exception e) {
            logger.log(Level.WARNING, "Failed to fetch flag definitions", e);
        }
    }

    private Map<String, ExperimentationFlag> parseDefinitions(String jsonResponse) {
        Map<String, ExperimentationFlag> definitions = new HashMap<>();

        try {
            JSONObject root = new JSONObject(jsonResponse);
            JSONArray flags = root.optJSONArray("flags");

            if (flags == null) {
                return definitions;
            }

            for (int i = 0; i < flags.length(); i++) {
                JSONObject flagJson = flags.getJSONObject(i);
                ExperimentationFlag flag = parseFlag(flagJson);
                definitions.put(flag.getKey(), flag);
            }
        } catch (Exception e) {
            logger.log(Level.SEVERE, "Failed to parse flag definitions", e);
        }

        return definitions;
    }

    private ExperimentationFlag parseFlag(JSONObject json) {
        String id = json.optString("id", "");
        String name = json.optString("name", "");
        String key = json.optString("key", "");
        String status = json.optString("status", "");
        int projectId = json.optInt("project_id", 0);
        String context = json.optString("context", "distinct_id");

        // Parse experiment metadata
        UUID experimentId = null;
        String experimentIdString = json.optString("experiment_id", null);
        if (experimentIdString != null && !experimentIdString.isEmpty()) {
            try {
                experimentId = UUID.fromString(experimentIdString);
            } catch (IllegalArgumentException e) {
                logger.log(Level.WARNING, "Invalid UUID for experiment_id: " + experimentIdString);
            }
        }

        Boolean isExperimentActive = null;
        if (json.has("is_experiment_active")) {
            isExperimentActive = json.optBool