FlagsmithClient.java

package com.flagsmith;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.flagsmith.config.FlagsmithCacheConfig;
import com.flagsmith.config.FlagsmithConfig;
import com.flagsmith.exceptions.FlagsmithApiError;
import com.flagsmith.exceptions.FlagsmithClientError;
import com.flagsmith.exceptions.FlagsmithRuntimeError;
import com.flagsmith.flagengine.Engine;
import com.flagsmith.flagengine.EvaluationContext;
import com.flagsmith.flagengine.EvaluationResult;
import com.flagsmith.flagengine.SegmentRule;
import com.flagsmith.flagengine.Segments;
import com.flagsmith.interfaces.FlagsmithCache;
import com.flagsmith.interfaces.FlagsmithSdk;
import com.flagsmith.mappers.EngineMappers;
import com.flagsmith.models.BaseFlag;
import com.flagsmith.models.ExperimentMetadata;
import com.flagsmith.models.Flag;
import com.flagsmith.models.Flags;
import com.flagsmith.models.Segment;
import com.flagsmith.models.SegmentMetadata;
import com.flagsmith.threads.EventProcessor;
import com.flagsmith.threads.PollingManager;
import com.flagsmith.utils.ModelUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.AccessLevel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NonNull;
import lombok.Setter;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A client for Flagsmith API.
 */
@Data
public class FlagsmithClient {

  private static final List<String> IDENTITY_FREE_PROPERTY_PREFIXES = List.of(
      "$.environment.", "$.environment[", "$.flags.", "$.flags[");

  private final FlagsmithLogger logger = new FlagsmithLogger();
  private FlagsmithSdk flagsmithSdk;
  private EvaluationContext evaluationContext;
  @Getter(AccessLevel.NONE)
  @Setter(AccessLevel.NONE)
  @EqualsAndHashCode.Exclude
  @ToString.Exclude
  private EvaluationContext environmentEvaluationContext;
  private PollingManager pollingManager;
  @Getter(AccessLevel.PACKAGE)
  @Setter(AccessLevel.NONE)
  private EventProcessor eventProcessor;

  private FlagsmithClient() {
  }

  public static FlagsmithClient.Builder newBuilder() {
    return new FlagsmithClient.Builder();
  }

  /**
   * Set the evaluation context, and derive the one environment flags evaluate against.
   *
   * @param evaluationContext the evaluation context
   */
  public void setEvaluationContext(EvaluationContext evaluationContext) {
    this.environmentEvaluationContext = evaluationContext == null
        ? null
        : new EvaluationContext(evaluationContext)
            .withSegments(getIdentityFreeSegments(evaluationContext.getSegments()));
    this.evaluationContext = evaluationContext;
  }

  /**
   * Load the environment flags in the environment variable from the API.
   */
  public void updateEnvironment() {
    try {
      EvaluationContext updatedEvaluationContext = flagsmithSdk.getEvaluationContext();

      // if we didn't get an environment from the API,
      // then don't overwrite the copy we already have.
      if (updatedEvaluationContext != null) {
        setEvaluationContext(updatedEvaluationContext);
      } else {
        logger.error(getEnvironmentUpdateErrorMessage());
      }
    } catch (RuntimeException e) {
      logger.error(getEnvironmentUpdateErrorMessage());
    }
  }

  /**
   * Get all the default for flags for the current environment.
   *
   * @return environment flags
   */
  public Flags getEnvironmentFlags() throws FlagsmithClientError {
    if (getShouldUseEnvironmentDocument()) {
      return getEnvironmentFlagsFromEvaluationContext();
    }

    return getEnvironmentFlagsFromApi();
  }

  /**
   * Get all the flags for the current environment for a given identity.
   *
   * @param identifier identifier string
   * @return result of flag evaluation for given identity
   */
  public Flags getIdentityFlags(String identifier)
      throws FlagsmithClientError {
    return getIdentityFlags(identifier, new HashMap<>());
  }

  /**
   * Get all the flags for the current environment for a given identity. Will also
   * upsert traits to the Flagsmith API for future evaluations.
   * 
   * <p>
   * A trait with a value of null will remove the trait from the identity if it
   * exists.
   * </p>
   * <p>
   * To specify a transient trait, use the TraitConfig class with isTransient set
   * to true as the trait value.
   * </p>
   *
   * @see com.flagsmith.models.TraitConfig
   * 
   * @param identifier identifier string
   * @param traits     a map of trait keys to trait values
   */
  public Flags getIdentityFlags(String identifier, Map<String, Object> traits)
      throws FlagsmithClientError {
    return getIdentityFlags(identifier, traits, false);
  }

  /**
   * Get all the flags for the current environment for a given identity. Will also
   * upsert traits to the Flagsmith API for future evaluations, if isTransient set
   * to false.
   * 
   * <p>
   * A trait with a value of null will remove the trait from the identity if it
   * exists.
   * </p>
   * <p>
   * To specify a transient trait, use the TraitConfig class with isTransient set
   * to true as the trait value.
   * </p>
   *
   * @see com.flagsmith.models.TraitConfig
   * 
   * @param identifier  identifier string
   * @param traits      a map of trait keys to trait values
   * @param isTransient set to true to prevent identity persistence
   * @return result of flag evaluation for given identity
   */
  public Flags getIdentityFlags(String identifier, Map<String, Object> traits, boolean isTransient)
      throws FlagsmithClientError {
    if (getShouldUseEnvironmentDocument()) {
      return getIdentityFlagsFromEvaluationContext(identifier, traits);
    }

    return getIdentityFlagsFromApi(identifier, traits, isTransient);
  }

  /**
   * Get a list of segments that the given identity is in.
   *
   * @param identifier a unique identifier for the identity in the current
   *                   environment, e.g. email address, username, uuid
   */
  public List<Segment> getIdentitySegments(String identifier)
      throws FlagsmithClientError {
    return getIdentitySegments(identifier, null);
  }

  /**
   * Get a list of segments that the given identity is in.
   *
   * @param identifier a unique identifier for the identity in the current
   *                   environment, e.g. email address, username, uuid
   * @param traits     a dictionary of traits to add / update on the identity in
   *                   Flagsmith, e.g. {"num_orders": 10}
   */
  public List<Segment> getIdentitySegments(String identifier, Map<String, Object> traits)
      throws FlagsmithClientError {
    if (evaluationContext == null) {
      throw new FlagsmithClientError("Local evaluation required to obtain identity segments.");
    }

    final EvaluationContext context = EngineMappers.mapContextAndIdentityDataToContext(
        evaluationContext, identifier, traits);

    final EvaluationResult result = Engine.getEvaluationResult(context);

    ObjectMapper mapper = MapperFactory.getMapper();

    return result.getSegments().stream().map((segmentModel) -> {
      if (segmentModel.getMetadata() == null) {
        return null;
      }

      SegmentMetadata segmentMetadata = mapper.convertValue(
          segmentModel.getMetadata(), SegmentMetadata.class);

      Integer flagsmithId = segmentMetadata.getFlagsmithId();
      if (segmentMetadata.getSource() != SegmentMetadata.Source.API
          || flagsmithId == null) {
        return null;
      }

      Segment segment = new Segment();
      segment.setId(flagsmithId);
      segment.setName(segmentModel.getName());

      return segment;
    }).filter(Objects::nonNull).collect(Collectors.toList());
  }

  /**
   * As {@link #getExperimentFlag(String, String, Map)}, with no traits.
   *
   * @param featureName feature name
   * @param identifier  identifier string
   * @return the flag for the given feature
   * @throws FlagsmithRuntimeError when events are not enabled
   * @throws FlagsmithApiError     when identity flags are unavailable and no default flag handler
   *                               is configured
   */
  public BaseFlag getExperimentFlag(String featureName, String identifier)
      throws FlagsmithClientError {
    return getExperimentFlag(featureName, identifier, new HashMap<>());
  }

  /**
   * Get an identity's flag, recording one {@code $flag_exposure} event if the identity is enrolled
   * in a running experiment on it. Only remote evaluation carries experiment metadata, so local
   * evaluation and offline mode record no exposure.
   *
   * @param featureName feature name
   * @param identifier  identifier string
   * @param traits      a map of trait keys to trait values
   * @return the flag for the given feature
   * @throws FlagsmithRuntimeError when events are not enabled
   * @throws FlagsmithApiError     when identity flags are unavailable and no default flag handler
   *                               is configured
   */
  public BaseFlag getExperimentFlag(
      String featureName, String identifier, Map<String, Object> traits)
      throws FlagsmithClientError {
    requireEventProcessor("get experiment flags");

    Flags flags = getIdentityFlags(identifier, traits);

    if (flags == null) {
      FlagsmithFlagDefaults defaults = getConfig().getFlagsmithFlagDefaults();
      if (defaults == null) {
        throw new FlagsmithApiError("Failed to get feature flags.");
      }
      logger.info("Not recording an exposure for feature {}: identity flags are unavailable, so "
          + "the default flag handler served it.", featureName);
      return defaults.evaluateDefaultFlag(featureName);
    }

    BaseFlag flag = flags.getFlag(featureName);

    if (!(flag instanceof Flag)) {
      logger.info("Not recording an exposure for feature {}: served by the default flag handler.",
          featureName);
      return flag;
    }

    if (!Boolean.TRUE.equals(flag.getEnabled())) {
      logger.info("Not recording an exposure for feature {}: the flag is disabled.", featureName);
      return flag;
    }

    ExperimentMetadata experiment = ((Flag) flag).getExperiment();
    if (experiment == null || !Boolean.TRUE.equals(experiment.getInExperiment())) {
      logger.info("Not recording an exposure for feature {}: the identity is not enrolled in a "
          + "running experiment.", featureName);
      return flag;
    }

    Map<String, Object> metadata = new HashMap<>();
    metadata.put("experiment_id", experiment.getId());
    trackExposureEvent(featureName, identifier, ((Flag) flag).getVariant(), traits, metadata);

    return flag;
  }

  /**
   * Record a custom event.
   *
   * @param event event name
   * @throws FlagsmithRuntimeError    when events are not enabled
   * @throws IllegalArgumentException when the event name is blank or starts with "$"
   */
  public void trackEvent(String event) {
    trackEvent(event, null, null, null, null);
  }

  /**
   * Record a custom event for an identity.
   *
   * @param event      event name
   * @param identifier identifier string
   * @throws FlagsmithRuntimeError    when events are not enabled
   * @throws IllegalArgumentException when the event name is blank or starts with "$"
   */
  public void trackEvent(String event, String identifier) {
    trackEvent(event, identifier, null, null, null);
  }

  /**
   * Record a custom event for an identity, with a value, traits and metadata.
   *
   * @param event      event name
   * @param identifier identifier string
   * @param value      event value, stringified before sending
   * @param traits     a map of trait keys to trait values
   * @param metadata   a map of metadata to attach to the event
   * @throws FlagsmithRuntimeError    when events are not enabled
   * @throws IllegalArgumentException when the event name is blank or starts with "$"
   */
  public void trackEvent(String event, String identifier, Object value,
      Map<String, Object> traits, Map<String, Object> metadata) {
    EventProcessor processor = requireEventProcessor("track events");

    if (StringUtils.isBlank(event)) {
      throw new IllegalArgumentException("An event name is required.");
    }
    if (event.startsWith("$")) {
      throw new IllegalArgumentException("Event names starting with \"$\" are reserved; use "
          + "trackExposureEvent to record \"" + EventProcessor.FLAG_EXPOSURE_EVENT + "\".");
    }

    processor.trackEvent(event, identifier, value, traits, metadata);
  }

  /**
   * Record a {@code $flag_exposure} event. Skipped, with a log line, when the identifier is
   * blank.
   *
   * @param featureName feature the identity was exposed to
   * @param identifier  identifier string
   * @param value       variant the identity was bucketed into
   * @throws FlagsmithRuntimeError    when events are not enabled
   * @throws IllegalArgumentException when the feature name is blank
   */
  public void trackExposureEvent(String featureName, String identifier, Object value) {
    trackExposureEvent(featureName, identifier, value, null, null);
  }

  /**
   * Record a {@code $flag_exposure} event, with traits and metadata. Skipped, with a log line,
   * when the identifier is blank.
   *
   * @param featureName feature the identity was exposed to
   * @param identifier  identifier string
   * @param value       variant the identity was bucketed into
   * @param traits      a map of trait keys to trait values
   * @param metadata    a map of metadata to attach to the event
   * @throws FlagsmithRuntimeError    when events are not enabled
   * @throws IllegalArgumentException when the feature name is blank
   */
  public void trackExposureEvent(String featureName, String identifier, Object value,
      Map<String, Object> traits, Map<String, Object> metadata) {
    EventProcessor processor = requireEventProcessor("track exposure events");

    if (StringUtils.isBlank(featureName)) {
      throw new IllegalArgumentException("An exposure requires a feature name.");
    }
    if (StringUtils.isBlank(identifier)) {
      logger.info("Not sending {} for feature {}: an exposure requires an identifier.",
          EventProcessor.FLAG_EXPOSURE_EVENT, featureName);
      return;
    }

    processor.trackExposureEvent(featureName, identifier, value, traits, metadata);
  }

  /**
   * Send buffered events now.
   *
   * @return a future completing once every event buffered so far has been sent or dropped, already
   *     completed when events are not enabled
   */
  public CompletableFuture<Void> flushEvents() {
    if (eventProcessor == null) {
      return CompletableFuture.completedFuture(null);
    }

    return eventProcessor.flush();
  }

  /**
   * Should be called when terminating the client to clean up any resources that
   * need cleaning up.
   **/
  public void close() {
    if (pollingManager != null) {
      pollingManager.stopPolling();
    }

    if (eventProcessor != null) {
      eventProcessor.close();
    }

    flagsmithSdk.close();
  }

  private EventProcessor requireEventProcessor(String action) {
    if (eventProcessor == null) {
      throw new FlagsmithRuntimeError(
          "Events must be enabled to " + action + ". Use withEnableEvents(true).");
    }

    return eventProcessor;
  }

  private Flags getEnvironmentFlagsFromEvaluationContext() throws FlagsmithClientError {
    final EvaluationContext context = environmentEvaluationContext;
    if (context == null) {
      if (getConfig().getFlagsmithFlagDefaults() == null) {
        throw new FlagsmithClientError("Unable to get flags. No environment present.");
      }
      return getDefaultFlags();
    }

    final EvaluationResult result = Engine.getEvaluationResult(context);

    return Flags.fromEvaluationResult(
        result,
        getConfig().getAnalyticsProcessor(),
        getConfig().getFlagsmithFlagDefaults());
  }

  /*
   * The segments that resolve without an identity, i.e. those whose every
   * condition reads only the environment or other flags.
   */
  private static Segments getIdentityFreeSegments(Segments segments) {
    if (segments == null) {
      return null;
    }
    Segments identityFreeSegments = new Segments();
    segments.getAdditionalProperties().forEach((segmentKey, segmentContext) -> {
      if (isIdentityFree(segmentContext.getRules())) {
        identityFreeSegments.setAdditionalProperty(segmentKey, segmentContext);
      }
    });
    return identityFreeSegments;
  }

  private static boolean isIdentityFree(List<SegmentRule> rules) {
    return rules == null || rules.stream().allMatch(rule ->
        (rule.getConditions() == null || rule.getConditions().stream().allMatch(condition ->
            condition.getProperty() != null
                && IDENTITY_FREE_PROPERTY_PREFIXES.stream()
                    .anyMatch(condition.getProperty()::startsWith)))
            && isIdentityFree(rule.getRules()));
  }

  private Flags getIdentityFlagsFromEvaluationContext(
      String identifier, Map<String, Object> traits)
      throws FlagsmithClientError {
    if (evaluationContext == null) {
      if (getConfig().getFlagsmithFlagDefaults() == null) {
        throw new FlagsmithClientError("Unable to get flags. No environment present.");
      }
      return getDefaultFlags();
    }

    final EvaluationContext context = EngineMappers.mapContextAndIdentityDataToContext(
        evaluationContext, identifier, traits);

    final EvaluationResult result = Engine.getEvaluationResult(context);

    return Flags.fromEvaluationResult(
        result,
        getConfig().getAnalyticsProcessor(),
        getConfig().getFlagsmithFlagDefaults());
  }

  private Flags getEnvironmentFlagsFromApi() throws FlagsmithApiError {
    try {
      return flagsmithSdk.getFeatureFlags(Boolean.TRUE);
    } catch (Exception e) {
      if (getConfig().getFlagsmithFlagDefaults() != null) {
        return getDefaultFlags();
      } else if (evaluationContext != null) {
        try {
          return getEnvironmentFlagsFromEvaluationContext();
        } catch (FlagsmithClientError ce) {
          // Do nothing and fall through to FlagsmithApiError
        }
      }

      throw new FlagsmithApiError("Failed to get feature flags.");
    }
  }

  private Flags getIdentityFlagsFromApi(
      String identifier, Map<String, Object> traits, boolean isTransient)
      throws FlagsmithApiError {
    try {
      return flagsmithSdk.identifyUserWithTraits(
          identifier,
          ModelUtils.getSdkTraitModelsFromTraitMap(traits),
          isTransient,
          Boolean.TRUE);
    } catch (Exception e) {
      if (getConfig().getFlagsmithFlagDefaults() != null) {
        return getDefaultFlags();
      } else if (evaluationContext != null) {
        try {
          return getIdentityFlagsFromEvaluationContext(identifier, traits);
        } catch (FlagsmithClientError ce) {
          // Do nothing and fall through to FlagsmithApiError
        }
      }

      throw new FlagsmithApiError("Failed to get feature flags.");
    }
  }

  private Flags getDefaultFlags() {
    Flags flags = new Flags();
    flags.setDefaultFlagHandler(getConfig().getFlagsmithFlagDefaults());
    return flags;
  }

  private String getEnvironmentUpdateErrorMessage() {
    if (this.evaluationContext == null) {
      return "Unable to update environment from API. "
          + "No environment configured - using defaultHandler if configured.";
    } else {
      return "Unable to update environment from API. Continuing to use previous copy.";
    }
  }

  private FlagsmithConfig getConfig() {
    return flagsmithSdk.getConfig();
  }

  /**
   * Returns a FlagsmithCache cache object that encapsulates methods to manipulate
   * the cache.
   *
   * @return a FlagsmithCache if enabled, otherwise null.
   */
  public FlagsmithCache getCache() {
    return this.flagsmithSdk.getCache();
  }

  /**
   * Returns a boolean indicating whether the flags should be retrieved from a
   * locally stored environment document instead of retrieved from the API.
   */
  private Boolean getShouldUseEnvironmentDocument() {
    FlagsmithConfig config = getConfig();
    return config.getEnableLocalEvaluation() | config.getOfflineMode();
  }

  public static class Builder {

    private final FlagsmithClient client;
    private FlagsmithConfig configuration = FlagsmithConfig.newBuilder().build();
    private HashMap<String, String> customHeaders;
    private String apiKey;
    private FlagsmithCacheConfig cacheConfig;
    private PollingManager pollingManager;
    private FlagsmithApiWrapper flagsmithApiWrapper;

    private Builder() {
      client = new FlagsmithClient();
    }

    /**
     * Set the environment API key.
     *
     * @param apiKey the api key for environment
     * @return the Builder
     */
    public Builder setApiKey(String apiKey) {
      if (null == apiKey) {
        throw new IllegalArgumentException("Api key can not be null");
      } else {
        this.apiKey = apiKey;
        return this;
      }
    }

    /**
     * When a flag does not exist in Flagsmith or there is an error, the SDK will
     * return null by
     * default.
     *
     * <p>If you would like to override this default behaviour, you can use this
     * method. By default
     * it will return null for any flags that it does not recognise.
     *
     * @param defaultFlagValueFunction the new function to use as default flag
     *                                 values
     * @return the Builder
     */
    public Builder setDefaultFlagValueFunction(
        @NonNull Function<String, BaseFlag> defaultFlagValueFunction) {
      if (this.configuration.getFlagsmithFlagDefaults() == null) {
        this.configuration.setFlagsmithFlagDefaults(new FlagsmithFlagDefaults());
      }
      this.configuration.getFlagsmithFlagDefaults()
          .setDefaultFlagValueFunc(defaultFlagValueFunction);
      return this;
    }

    /**
     * Enables logging, the project importing this module must include an
     * implementation slf4j in
     * their pom.
     *
     * @param level log error level.
     * @return the Builder
     */
    public Builder enableLogging(FlagsmithLoggerLevel level) {
      this.client.logger.setLogger(LoggerFactory.getLogger(FlagsmithClient.class), level);
      return this;
    }

    /**
     * Enables logging, the project importing this module must include an
     * implementation slf4j in
     * their pom.
     *
     * @return the Builder
     */
    public Builder enableLogging() {
      this.client.logger.setLogger(LoggerFactory.getLogger(FlagsmithClient.class));
      return this;
    }

    /**
     * Enables logging, the project importing this module must include an
     * implementation slf4j in
     * their pom.
     *
     * @return the Builder
     */
    public Builder enableLogging(Logger logger) {
      this.client.logger.setLogger(logger);
      return this;
    }

    /**
     * Override default FlagsmithConfig for Flagsmith API.
     *
     * @param config an FlagsmithConfig to override default one.
     * @return the Builder
     */
    public Builder withConfiguration(FlagsmithConfig config) {
      if (config != null) {
        this.configuration = config;
      }
      return this;
    }

    /**
     * Set the base URL for Flagsmith API, overriding default one.
     *
     * @param apiUrl the new base URI for the API.
     * @return the Builder
     */
    public Builder withApiUrl(String apiUrl) {
      if (apiUrl != null) {
        this.configuration = FlagsmithConfig.newBuilder()
            .baseUri(apiUrl)
            .build();
      }
      return this;
    }

    /**
     * Add custom HTTP headers to the Flags API calls. They are not sent to the events API.
     *
     * @param customHeaders headers.
     * @return the Builder
     */
    public Builder withCustomHttpHeaders(HashMap<String, String> customHeaders) {
      this.customHeaders = customHeaders;
      return this;
    }

    /**
     * Enable in-memory caching for the Flagsmith API.
     *
     * <p>If no other cache configuration is set, the Caffeine defaults will be used,
     * i.e. no limit
     *
     * @param cacheConfig an FlagsmithCacheConfig.
     * @return the Builder
     */
    public Builder withCache(FlagsmithCacheConfig cacheConfig) {
      this.cacheConfig = cacheConfig;
      return this;
    }

    /**
     * Set the polling manager.
     *
     * @param manager polling manager object
     */
    public Builder withPollingManager(PollingManager manager) {
      this.pollingManager = manager;
      return this;
    }

    /**
     * Set the api wrapper.
     *
     * @param flagsmithApiWrapper FlagsmithAPIWrapper object
     * @return the Builder
     */
    public Builder withFlagsmithApiWrapper(FlagsmithApiWrapper flagsmithApiWrapper) {
      this.flagsmithApiWrapper = flagsmithApiWrapper;
      return this;
    }

    /**
     * Builds a FlagsmithClient.
     *
     * @return a FlagsmithClient
     */
    public FlagsmithClient build() {
      if (configuration.getOfflineMode()) {
        if (configuration.getOfflineHandler() == null) {
          throw new FlagsmithRuntimeError("Offline handler must be provided to use offline mode.");
        }
        if (configuration.getEnableEvents()) {
          throw new FlagsmithRuntimeError("Events cannot be enabled in offline mode.");
        }
      }

      if (this.flagsmithApiWrapper != null) {
        client.flagsmithSdk = this.flagsmithApiWrapper;
      } else if (cacheConfig != null) {
        client.flagsmithSdk = new FlagsmithApiWrapper(
            cacheConfig.getCache(),
            this.configuration,
            this.customHeaders,
            client.logger,
            apiKey);
      } else {
        client.flagsmithSdk = new FlagsmithApiWrapper(
            this.configuration,
            this.customHeaders,
            client.logger,
            apiKey);
      }

      if (configuration.getAnalyticsProcessor() != null) {
        configuration.getAnalyticsProcessor().setApi(client.flagsmithSdk);
        configuration.getAnalyticsProcessor().setLogger(client.logger);
      }

      if (configuration.getEnableLocalEvaluation()) {
        if (configuration.getOfflineHandler() != null) {
          throw new FlagsmithRuntimeError(
              "Local evaluation and offline handler cannot be used together.");
        }

        if (!apiKey.startsWith("ser.")) {
          throw new FlagsmithRuntimeError(
              "In order to use local evaluation, please generate a server key "
                  + "in the environment settings page.");
        }
      }

      if (configuration.getOfflineHandler() != null) {
        if (configuration.getFlagsmithFlagDefaults() != null) {
          throw new FlagsmithRuntimeError(
              "Cannot use both default flag handler and offline handler.");
        }
        client.setEvaluationContext(EngineMappers.mapEnvironmentToContext(
            configuration.getOfflineHandler().getEnvironment()));
      }

      EventProcessor processor = null;
      if (configuration.getEnableEvents()) {
        processor = configuration.getEventProcessor() != null
            ? configuration.getEventProcessor()
            : new EventProcessor(
                configuration.getHttpClient(),
                configuration.getEventsUri(),
                configuration.getEventsMaxBufferItems(),
                configuration.getEventsFlushIntervalMillis());
        processor.claim();
      }

      if (configuration.getEnableLocalEvaluation()) {
        if (this.pollingManager != null) {
          client.pollingManager = pollingManager;
        } else {
          client.pollingManager = new PollingManager(
              client,
              configuration.getEnvironmentRefreshIntervalSeconds());
        }

        client.pollingManager.startPolling();
      }

      if (processor != null) {
        if (client.eventProcessor != null) {
          client.eventProcessor.close();
        }
        processor.setApi(client.flagsmithSdk);
        processor.setLogger(client.logger);
        processor.start();
        client.eventProcessor = processor;
      }

      return this.client;
    }
  }
}