chore: Add support for server-side hooks tests. (#498)

<!-- CURSOR_SUMMARY -->
> [!NOTE]
> Adds a new OpenTelemetry integration for the server SDK (tracing hook)
with example and tests, enables hooks in contract tests, and updates
build/CI/release to support it.
> 
> - **OpenTelemetry Integration (new package)**:
> - Adds `libs/server-sdk-otel` providing `TracingHook`
(`include/launchdarkly/server_side/integrations/otel/tracing_hook.hpp`,
`src/tracing_hook.cpp`) with options builder and unit tests.
> - CMake support with `LD_BUILD_OTEL_SUPPORT`,
`LD_BUILD_OTEL_FETCH_DEPS`, `LD_OTEL_CPP_VERSION`; links against
`opentelemetry-cpp::api`.
> - New example `examples/hello-cpp-server-otel` demonstrating tracing
hook and OTLP exporter.
> - **Contract Tests (hooks)**:
>   - Extends data model with `hooks` configuration and related types.
> - Implements `ContractTestHook` used by server test harness; registers
via config and advertises `evaluation-hooks` and `track-hooks`
capabilities.
> - **Build/CI/Release**:
> - Updates `scripts/build.sh` to build OTel targets and fetch deps when
needed.
> - Adds `install_curl` input to shared CI and uses it for OTel builds;
sets `CMAKE_PREFIX_PATH` for CURL.
> - New workflow `server-otel.yml` to build/test OTel on
Linux/macOS/Windows.
> - `release-please` config/manifests updated to include
`libs/server-sdk-otel` (v0.1.0) and outputs; docs workflow supports
`libs/server-sdk-otel`.
> - **CMake/Infra**:
> - Root `CMakeLists.txt` adds `LD_BUILD_OTEL_SUPPORT` option and
`add_subdirectory(libs/server-sdk-otel)`; examples gated on it.
> - `cmake/json.cmake` switches FetchContent name to `nlohmann_json` to
avoid target duplication.
>   - README documents new OTel options.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
e62e575. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: kinyoklion

contract-tests/data-model/include/data_model/data_model.hpp

@@ -113,6 +113,36 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigTags,
                                                 applicationId,
                                                 applicationVersion);
 
+enum class HookStage {
+    BeforeEvaluation,
+    AfterEvaluation,
+    AfterTrack
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(HookStage,
+                             {{HookStage::BeforeEvaluation, "beforeEvaluation"},
+                              {HookStage::AfterEvaluation, "afterEvaluation"},
+                              {HookStage::AfterTrack, "afterTrack"}})
+
+struct ConfigHookInstance {
+    std::string name;
+    std::string callbackUri;
+    std::optional<std::unordered_map<std::string, std::unordered_map<std::string, nlohmann::json>>> data;
+    std::optional<std::unordered_map<std::string, std::string>> errors;
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigHookInstance,
+                                                name,
+                                                callbackUri,
+                                                data,
+                                                errors);
+
+struct ConfigHooksParams {
+    std::vector<ConfigHookInstance> hooks;
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigHooksParams, hooks);
+
 struct ConfigParams {
     std::string credential;
     std::optional<uint32_t> startWaitTimeMs;
@@ -125,6 +155,7 @@ struct ConfigParams {
     std::optional<ConfigTags> tags;
     std::optional<ConfigTLSParams> tls;
     std::optional<ConfigProxyParams> proxy;
+    std::optional<ConfigHooksParams> hooks;
 };
 
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigParams,
@@ -138,7 +169,8 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigParams,
                                                 clientSide,
                                                 tags,
                                                 tls,
-                                                proxy);
+                                                proxy,
+                                                hooks);
 
 struct ContextSingleParams {
     std::optional<std::string> kind;

contract-tests/server-contract-tests/CMakeLists.txt

@@ -16,6 +16,7 @@ add_executable(server-tests
         src/session.cpp
         src/entity_manager.cpp
         src/client_entity.cpp
+        src/contract_test_hook.cpp
         )
 
 target_link_libraries(server-tests PRIVATE

contract-tests/server-contract-tests/include/contract_test_hook.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <data_model/data_model.hpp>
+#include <launchdarkly/server_side/hooks/hook.hpp>
+
+#include <boost/asio/any_io_executor.hpp>
+#include <memory>
+#include <string>
+
+/**
+ * ContractTestHook implements the Hook interface for contract testing.
+ *
+ * It posts hook execution payloads to a callback URI specified in the test
+ * configuration, allowing the test harness to verify hook behavior.
+ */
+class ContractTestHook : public launchdarkly::server_side::hooks::Hook {
+   public:
+    /**
+     * Constructs a contract test hook.
+     * @param executor IO executor for async HTTP operations.
+     * @param config Hook configuration from the test harness.
+     */
+    ContractTestHook(boost::asio::any_io_executor executor,
+                     ConfigHookInstance config);
+
+    ~ContractTestHook() override = default;
+
+    [[nodiscard]] launchdarkly::server_side::hooks::HookMetadata const&
+    Metadata() const override;
+
+    launchdarkly::server_side::hooks::EvaluationSeriesData BeforeEvaluation(
+        launchdarkly::server_side::hooks::EvaluationSeriesContext const&
+            series_context,
+        launchdarkly::server_side::hooks::EvaluationSeriesData data) override;
+
+    launchdarkly::server_side::hooks::EvaluationSeriesData AfterEvaluation(
+        launchdarkly::server_side::hooks::EvaluationSeriesContext const&
+            series_context,
+        launchdarkly::server_side::hooks::EvaluationSeriesData data,
+        launchdarkly::EvaluationDetail<launchdarkly::Value> const& detail)
+        override;
+
+    void AfterTrack(launchdarkly::server_side::hooks::TrackSeriesContext const&
+                        series_context) override;
+
+   private:
+    /**
+     * Posts a hook execution payload to the callback URI.
+     * @param stage The stage being executed.
+     * @param payload The JSON payload to send.
+     */
+    void PostCallback(std::string const& stage, nlohmann::json const& payload);
+
+    /**
+     * Gets configured data for a specific stage.
+     * @param stage The stage name.
+     * @return Optional map of key-value pairs for this stage.
+     */
+    std::optional<std::unordered_map<std::string, nlohmann::json>> GetDataForStage(
+        std::string const& stage) const;
+
+    /**
+     * Gets configured error for a specific stage.
+     * @param stage The stage name.
+     * @return Optional error message for this stage.
+     */
+    std::optional<std::string> GetErrorForStage(std::string const& stage) const;
+
+    boost::asio::any_io_executor executor_;
+    ConfigHookInstance config_;
+    launchdarkly::server_side::hooks::HookMetadata metadata_;
+};