fix(ruby): keep OpenTelemetry FFI config reference (#198)

* fix(ruby): keep OpenTelemetry FFI config buffers alive across init

build_config stored only the raw addresses of the nested traces/metrics
FFI struct wrappers and their endpoint string buffers into the config
struct, then let those wrapper objects go out of scope. The endpoint
MemoryPointers are retained by the wrapper struct instances, not by the
config struct (which holds only their backing addresses), so GC between
build_config returning and Bindings.init_open_telemetry running could
free the endpoint buffers -- leaving config->traces/metrics->endpoint
dangling when the native layer reads them (use-after-free).

build_config now returns [config_struct, keep_alive] where keep_alive
pins the nested struct wrappers and endpoint buffers; init stashes it in
@config_refs for the process lifetime (init is one-time), guaranteeing
the memory outlives the native call. Mirrors the buffer-pinning pattern
in build_command_args.

Related to #179.

Signed-off-by: Alex Le <alex.le@improving.com>

* refactor(ruby): release OTel config buffers after init instead of pinning for process lifetime

The native init_open_telemetry copies the endpoint strings synchronously
(CStr::from_ptr(...).to_string()) and retains no pointers, so the config
buffers only need to outlive the single FFI call. Hold keep_alive as a
local across the call and clear it afterwards rather than stashing it in
a process-lifetime @config_refs ivar. Also documents build_config's
two-element return and its buffer-pinning contract.

Related to #179.

Signed-off-by: Alex Le <alex.le@improving.com>

* docs: updated comments

Signed-off-by: Alex Le <alex.le@improving.com>

---------

Signed-off-by: Alex Le <alex.le@improving.com>

Author: Aryex

lib/valkey/opentelemetry.rb

@@ -98,10 +98,12 @@ def init(traces: nil, metrics: nil, flush_interval_ms: nil, parent_span_context_
         end
 
         # Build the configuration
-        config = build_config(traces, metrics, flush_interval_ms)
+        # keep_alive needs to be referenced so not to be GC'd before init_open_telemetry
+        # TODO: Refactor per https://github.com/valkey-io/valkey-glide-ruby/issues/179
+        config, keep_alive = build_config(traces, metrics, flush_interval_ms)
 
-        # Call the FFI function
         error_ptr = Bindings.init_open_telemetry(config)
+        keep_alive.clear # Needed to avoid linter warning.
 
         unless error_ptr.null?
           error_msg = error_ptr.read_string
@@ -223,15 +225,30 @@ def validate_parent_span_context!(ctx)
         raise ArgumentError, "tracestate must be a String or nil, got: #{tracestate.class}"
       end
 
+      # Build the native OpenTelemetry configuration struct from the given options.
+      #
+      # @param traces [Hash, nil] Traces configuration (see {init})
+      # @param metrics [Hash, nil] Metrics configuration (see {init})
+      # @param flush_interval_ms [Integer, nil] Flush interval in milliseconds
+      #
+      # @return [Array(Bindings::OpenTelemetryConfig, Array)] a two-element array of:
+      #   - the `config` struct to pass to `Bindings.init_open_telemetry`
+      #   - a `keep_alive` array containing references to values in `config`.
+      #     This is so the caller can keep them alive in their own scope, otherwise
+      #     they may be garbage collected before use.
+      #     TODO: Refactor per https://github.com/valkey-io/valkey-glide-ruby/issues/179
       def build_config(traces, metrics, flush_interval_ms)
         config_struct = Bindings::OpenTelemetryConfig.new
 
+        keep_alive = [config_struct]
+
         # Configure traces if provided
         if traces
           validate_endpoint!(traces[:endpoint], "traces")
 
           traces_struct = Bindings::OpenTelemetryTracesConfig.new
-          traces_struct[:endpoint] = FFI::MemoryPointer.from_string(traces[:endpoint])
+          endpoint_ptr = FFI::MemoryPointer.from_string(traces[:endpoint])
+          traces_struct[:endpoint] = endpoint_ptr
 
           if traces[:sample_percentage]
             traces_struct[:has_sample_percentage] = true
@@ -242,6 +259,8 @@ def build_config(traces, metrics, flush_interval_ms)
           end
 
           config_struct[:traces] = traces_struct.pointer
+          # Pin the wrapper (owns the endpoint ref) and the endpoint buffer.
+          keep_alive.push(traces_struct, endpoint_ptr)
         else
           config_struct[:traces] = FFI::Pointer::NULL
         end
@@ -251,8 +270,10 @@ def build_config(traces, metrics, flush_interval_ms)
           validate_endpoint!(metrics[:endpoint], "metrics")
 
           metrics_struct = Bindings::OpenTelemetryMetricsConfig.new
-          metrics_struct[:endpoint] = FFI::MemoryPointer.from_string(metrics[:endpoint])
+          endpoint_ptr = FFI::MemoryPointer.from_string(metrics[:endpoint])
+          metrics_struct[:endpoint] = endpoint_ptr
           config_struct[:metrics] = metrics_struct.pointer
+          keep_alive.push(metrics_struct, endpoint_ptr)
         else
           config_struct[:metrics] = FFI::Pointer::NULL
         end
@@ -266,7 +287,7 @@ def build_config(traces, metrics, flush_interval_ms)
           config_struct[:flush_interval_ms] = 5000 # Default
         end
 
-        config_struct
+        [config_struct, keep_alive]
       end
 
       def validate_endpoint!(endpoint, type)