Update example to use LD Observability by default.

Author: kinyoklion

examples/hello-cpp-server-otel/README.md

@@ -16,7 +16,6 @@ This example demonstrates how to integrate the LaunchDarkly C++ Server SDK with
 - CMake 3.19 or later
 - Boost 1.81 or later
 - LaunchDarkly SDK key
-- OpenTelemetry collector (or compatible backend) running on `localhost:4318`
 
 ## Building
 
@@ -30,33 +29,19 @@ cmake --build . --target hello-cpp-server-otel
 
 ## Running
 
-### 1. Start an OpenTelemetry Collector
-
-The easiest way is using Docker:
-
-```bash
-docker run -p 4318:4318 otel/opentelemetry-collector:latest
-```
-
-Or use Jaeger (which has a built-in OTLP receiver):
-
-```bash
-docker run -d -p 16686:16686 -p 4318:4318 jaegertracing/all-in-one:latest
-```
-
-### 2. Set Your LaunchDarkly SDK Key
+### 1. Set Your LaunchDarkly SDK Key
 
 Either edit `main.cpp` and set the `SDK_KEY` constant, or use an environment variable:
 
 ```bash
 export LD_SDK_KEY=your-sdk-key-here
 ```
 
-### 3. Create a Feature Flag
+### 2. Create a Feature Flag
 
 In your LaunchDarkly dashboard, create a boolean flag named `show-detailed-weather`.
 
-### 4. Run the Example
+### 3. Run the Example
 
 ```bash
 ./build/examples/hello-cpp-server-otel/hello-cpp-server-otel
@@ -69,74 +54,36 @@ You should see:
 
 *** Weather server running on http://0.0.0.0:8080
 *** Try: curl http://localhost:8080/weather
-*** OpenTelemetry tracing enabled (OTLP HTTP to localhost:4318)
+*** OpenTelemetry tracing enabled, sending traces to LaunchDarkly
 *** LaunchDarkly integration enabled with OpenTelemetry tracing hook
 ```
 
-### 5. Make Requests
+### 4. Make Requests
 
 ```bash
 curl http://localhost:8080/weather
 ```
 
-### 6. View Traces
-
-If using Jaeger, open http://localhost:16686 in your browser. You should see traces with:
+### 5. View Traces in LaunchDarkly
 
-- HTTP request spans
-- Feature flag evaluation events with attributes:
-  - `feature_flag.key`: "show-detailed-weather"
-  - `feature_flag.provider.name`: "LaunchDarkly"
-  - `feature_flag.context.id`: Context canonical key
-  - `feature_flag.result.value`: The flag value (since `IncludeValue` is enabled)
+1. Go to your LaunchDarkly project
+2. Navigate to the Observability section
+3. View traces containing your feature flag evaluations with attributes:
+   - `feature_flag.key`: "show-detailed-weather"
+   - `feature_flag.provider.name`: "LaunchDarkly"
+   - `feature_flag.context.id`: Context canonical key
+   - `feature_flag.result.value`: The flag value (since `IncludeValue` is enabled)
 
-## How It Works
+### Custom OTLP Endpoint
 
-### OpenTelemetry Setup
+To send traces to a different OpenTelemetry collector, set the `LD_OTEL_ENDPOINT` environment variable:
 
-```cpp
-void InitTracer() {
-    opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
-    opts.url = "http://localhost:4318/v1/traces";
-
-    auto exporter = opentelemetry::exporter::otlp::OtlpHttpExporterFactory::Create(opts);
-    auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-    std::shared_ptr<trace_api::TracerProvider> provider =
-            trace_sdk::TracerProviderFactory::Create(std::move(processor));
-    trace_api::Provider::SetTracerProvider(provider);
-}
-```
-
-### LaunchDarkly Hook Setup
-
-```cpp
-auto hook_options = launchdarkly::server_side::integrations::otel::TracingHookOptionsBuilder()
-                        .IncludeValue(true)   // Include flag values in traces
-                        .CreateSpans(false)   // Only create span events, not full spans
-                        .Build();
-auto tracing_hook = std::make_shared<launchdarkly::server_side::integrations::otel::TracingHook>(hook_options);
-
-auto config = launchdarkly::server_side::ConfigBuilder(sdk_key)
-        .Hooks(tracing_hook)
-        .Build();
-```
-
-### Passing Parent Span Context
-
-When using async frameworks like Boost.Beast, you need to manually pass the parent span:
-
-```cpp
-auto span = tracer->StartSpan("HTTP GET /weather");
-auto scope = trace_api::Scope(span);
-
-// Create hook context with the span
-auto hook_ctx = launchdarkly::server_side::integrations::otel::MakeHookContextWithSpan(span);
-
-// Pass it to the evaluation
-auto flag_value = ld_client->BoolVariation(context, "my-flag", false, hook_ctx);
+```bash
+export LD_OTEL_ENDPOINT=http://localhost:4318/v1/traces
+./build/examples/hello-cpp-server-otel/hello-cpp-server-otel
 ```
 
-This ensures feature flag events appear as children of the correct span.
+Note: The `/v1/traces` path is automatically appended to the endpoint.
 
 ## What You'll See
 
@@ -146,23 +93,20 @@ This ensures feature flag events appear as children of the correct span.
 *** SDK successfully initialized!
 
 *** Weather server running on http://0.0.0.0:8080
+*** Try: curl http://localhost:8080/weather
+*** OpenTelemetry tracing enabled, sending traces to LaunchDarkly
+*** LaunchDarkly integration enabled with OpenTelemetry tracing hook
 ```
 
-### In Your Traces
+### In LaunchDarkly Observability
 
-Each HTTP request will have:
+Navigate to your LaunchDarkly project's Observability section to view traces. Each HTTP request will have:
 1. **Root Span**: "HTTP GET /weather" with HTTP attributes
-2. **Span Event**: "feature_flag" with LaunchDarkly evaluation details
-
-Example trace structure:
-```
-HTTP GET /weather (span)
-  └─ feature_flag (event)
-     ├─ feature_flag.key: "show-detailed-weather"
-     ├─ feature_flag.provider.name: "LaunchDarkly"
-     ├─ feature_flag.context.id: "user:weather-api-user"
-     └─ feature_flag.result.value: "true"
-```
+2. **Feature Flag Event**: Attached to the span with evaluation details:
+   - `feature_flag.key`: "show-detailed-weather"
+   - `feature_flag.provider.name`: "LaunchDarkly"
+   - `feature_flag.context.id`: "user:weather-api-user"
+   - `feature_flag.result.value`: The evaluated flag value
 
 ## Customization
 

examples/hello-cpp-server-otel/main.cpp

@@ -11,6 +11,7 @@
 
 #include <opentelemetry/exporters/otlp/otlp_http_exporter_factory.h>
 #include <opentelemetry/exporters/otlp/otlp_http_exporter_options.h>
+#include <opentelemetry/sdk/resource/resource.h>
 #include <opentelemetry/sdk/trace/simple_processor_factory.h>
 #include <opentelemetry/sdk/trace/tracer_provider_factory.h>
 #include <opentelemetry/trace/provider.h>
@@ -46,16 +47,29 @@ namespace trace_sdk = opentelemetry::sdk::trace;
 namespace nostd = opentelemetry::nostd;
 
 // Initialize OpenTelemetry
-void InitTracer() {
+void InitTracer(char const* sdk_key) {
     opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
-    opts.url = "http://localhost:4318/v1/traces";
+
+    // Check for custom endpoint from environment variable
+    if (char const* custom_endpoint = std::getenv("LD_OTEL_ENDPOINT");
+        custom_endpoint && strlen(custom_endpoint)) {
+        opts.url = std::string(custom_endpoint);
+    } else {
+        opts.url = "https://otel.observability.app.launchdarkly.com:4318/v1/traces";
+    }
+
+    // Create resource with highlight.project_id attribute
+    auto resource_attributes = opentelemetry::sdk::resource::ResourceAttributes{
+        {"highlight.project_id", sdk_key}
+    };
+    auto resource = opentelemetry::sdk::resource::Resource::Create(resource_attributes);
 
     auto exporter =
         opentelemetry::exporter::otlp::OtlpHttpExporterFactory::Create(opts);
     auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(
         std::move(exporter));
     const std::shared_ptr<trace_api::TracerProvider> provider =
-        trace_sdk::TracerProviderFactory::Create(std::move(processor));
+        trace_sdk::TracerProviderFactory::Create(std::move(processor), resource);
     trace_api::Provider::SetTracerProvider(provider);
 }
 
@@ -253,9 +267,6 @@ class listener : public std::enable_shared_from_this<listener> {
 };
 
 int main() {
-    // Initialize OpenTelemetry
-    InitTracer();
-
     // Initialize LaunchDarkly
     char const* sdk_key = get_with_env_fallback(
         SDK_KEY, "LD_SDK_KEY",
@@ -264,6 +275,9 @@ int main() {
         "variable.\n"
         "The value of SDK_KEY in main.cpp takes priority over LD_SDK_KEY.");
 
+    // Initialize OpenTelemetry
+    InitTracer(sdk_key);
+
     // Create the OpenTelemetry tracing hook using builder pattern
     auto hook_options =
         launchdarkly::server_side::integrations::otel::TracingHookOptionsBuilder()
@@ -315,7 +329,7 @@ int main() {
         std::cout << "*** Weather server running on http://0.0.0.0:8080\n";
         std::cout << "*** Try: curl http://localhost:8080/weather\n";
         std::cout <<
-            "*** OpenTelemetry tracing enabled (OTLP HTTP to localhost:4318)\n";
+            "*** OpenTelemetry tracing enabled, sending traces to LaunchDarkly\n";
         std::cout <<
             "*** LaunchDarkly integration enabled with OpenTelemetry tracing hook\n\n";