client_impl.cpp

#include "client_impl.hpp"

#include "all_flags_state/all_flags_state_builder.hpp"
#include "data_systems/background_sync/background_sync_system.hpp"
#include "data_systems/lazy_load/lazy_load_system.hpp"
#include "data_systems/offline.hpp"
#include "evaluation/evaluation_stack.hpp"
#include "prereq_event_recorder/prereq_event_recorder.hpp"

#include "data_interfaces/system/idata_system.hpp"

#include <launchdarkly/config/shared/built/http_properties.hpp>
#include <launchdarkly/encoding/sha_256.hpp>
#include <launchdarkly/events/asio_event_processor.hpp>
#include <launchdarkly/events/data/common_events.hpp>
#include <launchdarkly/logging/console_backend.hpp>
#include <launchdarkly/logging/null_logger.hpp>

#include <launchdarkly/server_side/config/builders/all_builders.hpp>
#include <launchdarkly/server_side/config/built/all_built.hpp>

#include <chrono>
#include <optional>
#include <utility>

namespace launchdarkly::server_side {

using EventProcessor = events::AsioEventProcessor<config::builders::SDK>;

// The ASIO implementation assumes that the io_context will be run from a
// single thread, and applies several optimisations based on this
// assumption.
auto const kAsioConcurrencyHint = 1;

// Client's destructor attempts to gracefully shut down the datasource
// connection in this amount of time.
auto const kDataSourceShutdownWait = std::chrono::milliseconds(100);

// Hook method names
// Method names for hooks
static const std::string kMethodBoolVariation = "BoolVariation";
static const std::string kMethodBoolVariationDetail = "BoolVariationDetail";
static const std::string kMethodStringVariation = "StringVariation";
static const std::string kMethodStringVariationDetail = "StringVariationDetail";
static const std::string kMethodDoubleVariation = "DoubleVariation";
static const std::string kMethodDoubleVariationDetail = "DoubleVariationDetail";
static const std::string kMethodIntVariation = "IntVariation";
static const std::string kMethodIntVariationDetail = "IntVariationDetail";
static const std::string kMethodJsonVariation = "JsonVariation";
static const std::string kMethodJsonVariationDetail = "JsonVariationDetail";

static std::unique_ptr<data_interfaces::IDataSystem> MakeDataSystem(
    config::built::HttpProperties const& http_properties,
    Config const& config,
    boost::asio::any_io_executor const& executor,
    data_components::DataSourceStatusManager& status_manager,
    Logger& logger) {
    if (config.DataSystemConfig().disabled) {
        return std::make_unique<data_systems::OfflineSystem>(status_manager);
    }

    auto const builder =
        config::builders::HttpPropertiesBuilder(http_properties);

    auto data_source_properties = builder.Build();

    return std::visit(
        [&](auto&& arg) -> std::unique_ptr<data_interfaces::IDataSystem> {
            using T = std::decay_t<decltype(arg)>;
            if constexpr (std::is_same_v<T,
                                         config::built::BackgroundSyncConfig>) {
                return std::make_unique<data_systems::BackgroundSync>(
                    config.ServiceEndpoints(), arg, data_source_properties,
                    executor, status_manager, logger);
            } else if constexpr (std::is_same_v<
                                     T, config::built::LazyLoadConfig>) {
                return std::make_unique<data_systems::LazyLoad>(logger, arg,
                                                                status_manager);
            }
        },
        config.DataSystemConfig().system_);
}

static Logger MakeLogger(config::built::Logging const& config) {
    if (config.disable_logging) {
        return {std::make_shared<logging::NullLoggerBackend>()};
    }
    if (config.backend) {
        return {config.backend};
    }
    return {
        std::make_shared<logging::ConsoleBackend>(config.level, config.tag)};
}

std::unique_ptr<EventProcessor> MakeEventProcessor(
    Config const& config,
    boost::asio::any_io_executor const& exec,
    config::built::HttpProperties const& http_properties,
    Logger& logger) {
    if (config.Events().Enabled()) {
        return std::make_unique<EventProcessor>(exec, config.ServiceEndpoints(),
                                                config.Events(),
                                                http_properties, logger);
    }
    return nullptr;
}

/**
 * Returns true if the flag pointer is valid and the underlying item is
 * present.
 */
bool IsFlagPresent(
    std::shared_ptr<data_model::FlagDescriptor> const& flag_desc);

ClientImpl::ClientImpl(Config config, std::string const& version)
    : config_(config),
      http_properties_(
          config::builders::HttpPropertiesBuilder(config.HttpProperties())
              .Header("user-agent", "CPPServer/" + version)
              .Header("authorization", config.SdkKey())
              .Header("x-launchdarkly-tags", config.ApplicationTag())
              .Build()),
      logger_(MakeLogger(config.Logging())),
      ioc_(kAsioConcurrencyHint),
      work_(boost::asio::make_work_guard(ioc_)),
      status_manager_(),
      data_system_(MakeDataSystem(http_properties_,
                                  config_,
                                  ioc_.get_executor(),
                                  status_manager_,
                                  logger_)),
      event_processor_(MakeEventProcessor(config,
                                          ioc_.get_executor(),
                                          http_properties_,
                                          logger_)),
      evaluator_(logger_, *data_system_),
      events_default_(event_processor_.get(), EventFactory::WithoutReasons()),
      events_with_reasons_(event_processor_.get(),
                           EventFactory::WithReasons()) {
    LD_LOG(logger_, LogLevel::kDebug)
        << "data system: " << data_system_->Identity();
    if (auto custom_ca = http_properties_.Tls().CustomCAFile()) {
        LD_LOG(logger_, LogLevel::kInfo)
            << "TLS peer verification configured with custom CA file: "
            << *custom_ca;
    }
    if (http_properties_.Tls().PeerVerifyMode() ==
        launchdarkly::config::shared::built::TlsOptions::VerifyMode::
            kVerifyNone) {
        LD_LOG(logger_, LogLevel::kInfo) << "TLS peer verification disabled";
    }

    run_thread_ = std::move(std::thread([&]() { ioc_.run(); }));
}

void ClientImpl::Identify(Context context) {
    events_default_.Send([&](EventFactory const& factory) {
        return factory.Identify(std::move(context));
    });
}

std::future<bool> ClientImpl::StartAsync() {
    auto pr = std::make_shared<std::promise<bool>>();
    auto fut = pr->get_future();

    status_manager_.OnDataSourceStatusChangeEx([this, pr](auto _) {
        if (data_system_->Initialized()) {
            pr->set_value(true);
            return true; /* delete this change listener since the
                            desired state was reached */
        }
        return false; /* keep the change listener */
    });

    data_system_->Initialize();

    return fut;
}

bool ClientImpl::Initialized() const {
    return data_system_->Initialized();
}

AllFlagsState ClientImpl::AllFlagsState(Context const& context,
                                        AllFlagsState::Options options) {
    std::unordered_map<Client::FlagKey, Value> result;

    if (!Initialized()) {
        if (data_system_->CanEvaluateWhenNotInitialized()) {
            LD_LOG(logger_, LogLevel::kWarn)
                << "AllFlagsState() called before LaunchDarkly client "
                   "initialization completed; using last known values "
                   "from data store";
        } else {
            LD_LOG(logger_, LogLevel::kWarn)
                << "AllFlagsState() called before client has finished "
                   "initializing. Data source not available. Returning "
                   "empty state";

            return {};
        }
    }

    AllFlagsStateBuilder builder{options};

    auto all_flags = data_system_->AllFlags();

    // Because evaluating the flags may access many segments, tell the data
    // system to fetch them all at once up-front. This may be a no-op
    // depending on the data system (e.g. if the segments are all already in
    // memory.)
    auto _ = data_system_->AllSegments();

    for (auto const& [key, v] : all_flags) {
        if (!v || !v->item) {
            continue;
        }

        auto const& flag = *(v->item);

        if (IsSet(options, AllFlagsState::Options::ClientSideOnly) &&
            !flag.clientSideAvailability.usingEnvironmentId) {
            continue;
        }

        PrereqEventRecorder recorder{key};

        EvaluationDetail<Value> detail = evaluator_.Evaluate(
            flag, context,
            EventScope{&recorder, EventFactory::WithoutReasons()});

        bool in_experiment = flag.IsExperimentationEnabled(detail.Reason());

        builder.AddFlag(key, detail.Value(),
                        AllFlagsState::State{
                            flag.Version(), detail.VariationIndex(),
                            detail.Reason(), flag.trackEvents || in_experiment,
                            in_experiment, flag.debugEventsUntilDate,
                            std::move(recorder).TakePrerequisites()});
    }

    return builder.Build();
}

void ClientImpl::TrackInternal(Context const& ctx,
                               std::string event_name,
                               std::optional<Value> data,
                               std::optional<double> metric_value,
                               hooks::HookContext const& hook_context) {

    if (!ctx.Valid()) {
        LD_LOG(logger_, LogLevel::kWarn) << "Track method called with an invalid context";
        return;
    }
    // Execute afterTrack hooks before moving the data
    // Typically we would execute this after the data has been enqueued.
    // In this SDK doing so would introduce a performance penalty because we
    // would need to copy the event_name and data.
    // In this SDK the data is type-safe, and will be enqueued, so it makes
    // minimal functional difference.
    if (!config_.Hooks().empty()) {
        hooks::TrackSeriesContext series_context(ctx, event_name, metric_value,
                                                  data, hook_context, std::nullopt);
        hooks::ExecuteAfterTrack(config_.Hooks(), series_context, logger_);
    }

    events_default_.Send([&](EventFactory const& factory) {
        return factory.Custom(ctx, std::move(event_name), std::move(data),
                              metric_value);
    });
}

void ClientImpl::Track(Context const& ctx,
                       std::string event_name,
                       Value data,
                       double metric_value) {
    static hooks::HookContext empty_hook_context;
    this->TrackInternal(ctx, std::move(event_name), std::move(data),
                        metric_value, empty_hook_context);
}

void ClientImpl::Track(Context const& ctx,
                       std::string event_name,
                       Value data,
                       double metric_value,
                       hooks::HookContext const& hook_context) {
    this->TrackInternal(ctx, std::move(event_name), std::move(data),
                        metric_value, hook_context);
}

void ClientImpl::Track(Context const& ctx, std::string event_name, Value data) {
    static hooks::HookContext empty_hook_context;
    this->TrackInternal(ctx, std::move(event_name), std::move(data),
                        std::nullopt, empty_hook_context);
}

void ClientImpl::Track(Context const& ctx,
                       std::string event_name,
                       Value data,
                       hooks::HookContext const& hook_context) {
    this->TrackInternal(ctx, std::move(event_name), std::move(data),
                        std::nullopt, hook_context);
}

void ClientImpl::Track(Context const& ctx, std::string event_name) {
    static hooks::HookContext empty_hook_context;
    this->TrackInternal(ctx, std::move(event_name), std::nullopt, std::nullopt,
                        empty_hook_context);
}

void ClientImpl::Track(Context const& ctx,
                       std::string event_name,
                       hooks::HookContext const& hook_context) {
    this->TrackInternal(ctx, std::move(event_name), std::nullopt, std::nullopt,
                        hook_context);
}

void ClientImpl::FlushAsync() {
    if (event_processor_) {
        event_processor_->FlushAsync();
    }
}

void ClientImpl::LogVariationCall(std::string const& key,
                                  bool flag_present) const {
    if (Initialized()) {
        if (!flag_present) {
            LD_LOG(logger_, LogLevel::kInfo) << "Unknown feature flag " << key
                                             << "; returning default value";
        }
    } else {
        if (flag_present) {
            LD_LOG(logger_, LogLevel::kInfo)
                << "LaunchDarkly client has not yet been initialized; using "
                   "last "
                   "known flag rules from data store";
        } else {
            LD_LOG(logger_, LogLevel::kInfo)
                << "LaunchDarkly client has not yet been initialized; "
                   "returning default value";
        }
    }
}

Value ClientImpl::Variation(Context const& ctx,
                            enum Value::Type value_type,
                            IClient::FlagKey const& key,
                            Value const& default_value,
                            hooks::HookContext const& hook_context,
                            std::string const& method_name) {
    auto result = *VariationInternal(ctx, key, default_value, events_default_,
                                     hook_context, method_name);
    if (result.Type() != value_type) {
        return default_value;
    }
    return result;
}

EvaluationDetail<Value> ClientImpl::VariationInternal(
    Context const& context,
    IClient::FlagKey const& key,
    Value const& default_value,
    EventScope const& event_scope,
    hooks::HookContext const& hook_context,
    std::string const& method_name) {
    // Execute beforeEvaluation hooks
    std::optional<hooks::EvaluationSeriesExecutor> executor;
    if (!config_.Hooks().empty()) {
        hooks::EvaluationSeriesContext series_context(
            key, context, default_value, method_name, hook_context, std::nullopt);
        // Executor only created if there are hooks.
        executor.emplace(config_.Hooks(), logger_);
        executor->BeforeEvaluation(series_context);
    }

    if (auto error = PreEvaluationChecks(context)) {
        auto detail = PostEvaluation(key, context, default_value, *error,
                                     event_scope, std::nullopt);

        // Execute afterEvaluation hooks
        if (executor) {
            hooks::EvaluationSeriesContext series_context(
                key, context, default_value, method_name, hook_context, std::nullopt);
            executor->AfterEvaluation(series_context, detail);
        }

        return detail;
    }

    auto flag_rule = data_system_->GetFlag(key);

    bool flag_present = IsFlagPresent(flag_rule);

    LogVariationCall(key, flag_present);

    if (!flag_present) {
        auto detail = PostEvaluation(key, context, default_value,
                                     EvaluationReason::ErrorKind::kFlagNotFound,
                                     event_scope, std::nullopt);

        // Execute afterEvaluation hooks
        if (executor) {
            hooks::EvaluationSeriesContext series_context(
                key, context, default_value, method_name, hook_context, std::nullopt);
            executor->AfterEvaluation(series_context, detail);
        }

        return detail;
    }

    EvaluationDetail<Value> result =
        evaluator_.Evaluate(*flag_rule->item, context, event_scope);
    auto detail = PostEvaluation(key, context, default_value, result,
                                 event_scope, flag_rule.get()->item);

    // Execute afterEvaluation hooks
    if (executor) {
        hooks::EvaluationSeriesContext series_context(
            key, context, default_value, method_name, hook_context, std::nullopt);
        executor->AfterEvaluation(series_context, detail);
    }

    return detail;
}

std::optional<enum EvaluationReason::ErrorKind> ClientImpl::PreEvaluationChecks(
    Context const& context) const {
    if (!Initialized()) {
        if (data_system_->CanEvaluateWhenNotInitialized()) {
            LD_LOG(logger_, LogLevel::kWarn)
                << "Evaluation called before LaunchDarkly client "
                   "initialization completed; using last known values "
                   "from data store. The $inited key was not found in "
                   "the store; typically a Relay Proxy or other SDK "
                   "should set this key.";
        } else {
            return EvaluationReason::ErrorKind::kClientNotReady;
        }
    }
    if (!context.Valid()) {
        return EvaluationReason::ErrorKind::kUserNotSpecified;
    }
    return std::nullopt;
}

EvaluationDetail<Value> ClientImpl::PostEvaluation(
    std::string const& key,
    Context const& context,
    Value const& default_value,
    std::variant<enum EvaluationReason::ErrorKind, EvaluationDetail<Value>>
        error_or_detail,
    EventScope const& event_scope,
    std::optional<data_model::Flag> const& flag) {
    return std::visit(
        [&](auto&& arg) {
            using T = std::decay_t<decltype(arg)>;
            // VARIANT: ErrorKind
            if constexpr (std::is_same_v<T, enum EvaluationReason::ErrorKind>) {
                auto detail = EvaluationDetail<Value>{arg, default_value};

                event_scope.Send([&](EventFactory const& factory) {
                    return factory.UnknownFlag(key, context, detail,
                                               default_value);
                });

                return detail;
            }
            // VARIANT: EvaluationDetail
            else if constexpr (std::is_same_v<T, EvaluationDetail<Value>>) {
                auto detail = EvaluationDetail<Value>{
                    (!arg.VariationIndex() ? default_value : arg.Value()),
                    arg.VariationIndex(), arg.Reason()};

                event_scope.Send([&](EventFactory const& factory) {
                    return factory.Eval(key, context, flag, detail,
                                        default_value, std::nullopt);
                });

                return detail;
            }
        },
        std::move(error_or_detail));
}

bool IsFlagPresent(
    std::shared_ptr<data_model::FlagDescriptor> const& flag_desc) {
    return flag_desc && flag_desc->item;
}

EvaluationDetail<bool> ClientImpl::BoolVariationDetail(
    Context const& ctx,
    IClient::FlagKey const& key,
    bool default_value) {
    static hooks::HookContext empty_hook_context;
    return VariationDetail<bool>(ctx, Value::Type::kBool, key, default_value,
                                 empty_hook_context, kMethodBoolVariationDetail);
}

EvaluationDetail<bool> ClientImpl::BoolVariationDetail(
    Context const& ctx,
    IClient::FlagKey const& key,
    bool default_value,
    hooks::HookContext const& hook_context) {
    return VariationDetail<bool>(ctx, Value::Type::kBool, key, default_value,
                                 hook_context, kMethodBoolVariationDetail);
}

bool ClientImpl::BoolVariation(Context const& ctx,
                               IClient::FlagKey const& key,
                               bool default_value) {
    static hooks::HookContext empty_hook_context;
    return Variation(ctx, Value::Type::kBool, key, default_value,
                     empty_hook_context, kMethodBoolVariation);
}

bool ClientImpl::BoolVariation(Context const& ctx,
                               IClient::FlagKey const& key,
                               bool default_value,
                               hooks::HookContext const& hook_context) {
    return Variation(ctx, Value::Type::kBool, key, default_value,
                     hook_context, kMethodBoolVariation);
}

EvaluationDetail<std::string> ClientImpl::StringVariationDetail(
    Context const& ctx,
    ClientImpl::FlagKey const& key,
    std::string default_value) {
    static hooks::HookContext empty_hook_context;
    return VariationDetail<std::string>(ctx, Value::Type::kString, key,
                                        default_value, empty_hook_context,
                                        kMethodStringVariationDetail);
}

EvaluationDetail<std::string> ClientImpl::StringVariationDetail(
    Context const& ctx,
    ClientImpl::FlagKey const& key,
    std::string default_value,
    hooks::HookContext const& hook_context) {
    return VariationDetail<std::string>(ctx, Value::Type::kString, key,
                                        default_value, hook_context,
                                        kMethodStringVariationDetail);
}

std::string ClientImpl::StringVariation(Context const& ctx,
                                        IClient::FlagKey const& key,
                                        std::string default_value) {
    static hooks::HookContext empty_hook_context;
    return Variation(ctx, Value::Type::kString, key, default_value,
                     empty_hook_context, kMethodStringVariation);
}

std::string ClientImpl::StringVariation(Context const& ctx,
                                        IClient::FlagKey const& key,
                                        std::string default_value,
                                        hooks::HookContext const& hook_context) {
    return Variation(ctx, Value::Type::kString, key, default_value,
                     hook_context, kMethodStringVariation);
}

EvaluationDetail<double> ClientImpl::DoubleVariationDetail(
    Context const& ctx,
    ClientImpl::FlagKey const& key,
    double default_value) {
    static hooks::HookContext empty_hook_context;
    return VariationDetail<double>(ctx, Value::Type::kNumber, key,
                                   default_value, empty_hook_context,
                                   kMethodDoubleVariationDetail);
}

EvaluationDetail<double> ClientImpl::DoubleVariationDetail(
    Context const& ctx,
    ClientImpl::FlagKey const& key,
    double default_value,
    hooks::HookContext const& hook_context) {
    return VariationDetail<double>(ctx, Value::Type::kNumber, key,
                                   default_value, hook_context,
                                   kMethodDoubleVariationDetail);
}

double ClientImpl::DoubleVariation(Context const& ctx,
                                   IClient::FlagKey const& key,
                                   double default_value) {
    static hooks::HookContext empty_hook_context;
    return Variation(ctx, Value::Type::kNumber, key, default_value,
                     empty_hook_context, kMethodDoubleVariation);
}

double ClientImpl::DoubleVariation(Context const& ctx,
                                   IClient::FlagKey const& key,
                                   double default_value,
                                   hooks::HookContext const& hook_context) {
    return Variation(ctx, Value::Type::kNumber, key, default_value,
                     hook_context, kMethodDoubleVariation);
}

EvaluationDetail<int> ClientImpl::IntVariationDetail(
    Context const& ctx,
    IClient::FlagKey const& key,
    int default_value) {
    static hooks::HookContext empty_hook_context;
    return VariationDetail<int>(ctx, Value::Type::kNumber, key, default_value,
                                empty_hook_context, kMethodIntVariationDetail);
}

EvaluationDetail<int> ClientImpl::IntVariationDetail(
    Context const& ctx,
    IClient::FlagKey const& key,
    int default_value,
    hooks::HookContext const& hook_context) {
    return VariationDetail<int>(ctx, Value::Type::kNumber, key, default_value,
                                hook_context, kMethodIntVariationDetail);
}

int ClientImpl::IntVariation(Context const& ctx,
                             IClient::FlagKey const& key,
                             int default_value) {
    static hooks::HookContext empty_hook_context;
    return Variation(ctx, Value::Type::kNumber, key, default_value,
                     empty_hook_context, kMethodIntVariation);
}

int ClientImpl::IntVariation(Context const& ctx,
                             IClient::FlagKey const& key,
                             int default_value,
                             hooks::HookContext const& hook_context) {
    return Variation(ctx, Value::Type::kNumber, key, default_value,
                     hook_context, kMethodIntVariation);
}

EvaluationDetail<Value> ClientImpl::JsonVariationDetail(
    Context const& ctx,
    IClient::FlagKey const& key,
    Value default_value) {
    static hooks::HookContext empty_hook_context;
    return VariationInternal(ctx, key, default_value, events_with_reasons_,
                             empty_hook_context, kMethodJsonVariationDetail);
}

EvaluationDetail<Value> ClientImpl::JsonVariationDetail(
    Context const& ctx,
    IClient::FlagKey const& key,
    Value default_value,
    hooks::HookContext const& hook_context) {
    return VariationInternal(ctx, key, default_value, events_with_reasons_,
                             hook_context, kMethodJsonVariationDetail);
}

Value ClientImpl::JsonVariation(Context const& ctx,
                                IClient::FlagKey const& key,
                                Value default_value) {
    static hooks::HookContext empty_hook_context;
    return *VariationInternal(ctx, key, default_value, events_default_,
                              empty_hook_context, kMethodJsonVariation);
}

Value ClientImpl::JsonVariation(Context const& ctx,
                                IClient::FlagKey const& key,
                                Value default_value,
                                hooks::HookContext const& hook_context) {
    return *VariationInternal(ctx, key, default_value, events_default_,
                              hook_context, kMethodJsonVariation);
}

IDataSourceStatusProvider& ClientImpl::DataSourceStatus() {
    return status_manager_;
}

ClientImpl::~ClientImpl() {
    ioc_.stop();
    // TODO(SC-219101)
    run_thread_.join();
}
}  // namespace launchdarkly::server_side