simforge 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 712b471d28942f55c0ac0a78d05507f1060396de60c584173d3824f1e8c6d9b7
-  data.tar.gz: efa9dfc4e4173382d853327ee4edeafa54114482e04d97c86a3933465ee24285
+  metadata.gz: 0eaad388f5419c3933530ac93808928f219682b1e32d35fff040f691cbd4f410
+  data.tar.gz: a7922a5c2a3f063b5f6c13f43e5f6defed320c82d9b8d887a3cc12293ab03808
 SHA512:
-  metadata.gz: 1ca7cb706679154120fc89cac714b7d2eaa45017389f33f726afee7a77a0a0d1203dd7e14da32c8aa042d828381654bb87fe42fcb75c276edf61c52a27ba83e8
-  data.tar.gz: b9d9f5e70bf640447f046f9e272054c5f27f2aba849f42df20c6424c7a11c923c3403f89b23d0eb6b9eb50d53c39d0292b99213a5c4e2b745c7580948613a7d9
+  metadata.gz: 32b1df24c8a1dd4aa8acb6b5ca6828736c1a3b5586982a169865acaaa753075b4e06009f6c2d0d6843e9ec29539cba0a28c4e0df83eaaeef65f31b98e1449637
+  data.tar.gz: 2abbabfde142faa7c8ca0adc6e7433787f16b6b60aaafd28d26bd23c0fc890be852bdae342312540fc97e081bea05d163af66ae1b043f393c05c1f63ddd94d44

data/README.md

@@ -0,0 +1,342 @@
+# Simforge Ruby SDK
+
+Ruby client library for [Simforge](https://simforge.goharvest.ai) - trace and monitor your Ruby application's function execution with nested span support.
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'simforge'
+```
+
+Or install directly:
+
+```bash
+gem install simforge
+```
+
+## Requirements
+
+- Ruby >= 3.1
+- No external runtime dependencies (uses stdlib only)
+
+## Quick Start
+
+```ruby
+require 'simforge'
+
+# Configure once at application startup
+Simforge.configure(
+  api_key: ENV.fetch('SIMFORGE_API_KEY')
+)
+
+# Add tracing to your classes
+class OrderService
+  include Simforge::Traceable
+  simforge_function "order-processing"
+
+  simforge_span :process_order, type: "function"
+  def process_order(order_id)
+    # Your code here
+    { status: "completed" }
+  end
+end
+
+# Use your code normally - spans are sent automatically
+service = OrderService.new
+service.process_order("order-123")
+
+# Flush traces before exit (automatic via at_exit hook)
+Simforge.flush_traces
+```
+
+## Configuration
+
+### Basic Configuration
+
+```ruby
+Simforge.configure(
+  api_key: "your-api-key"
+)
+```
+
+### Custom Service URL
+
+```ruby
+Simforge.configure(
+  api_key: "your-api-key",
+  service_url: "https://custom.example.com"
+)
+```
+
+### Disabling Span Sending
+
+The `enabled` option controls whether spans are sent to Simforge. When disabled, your code executes normally but no spans are created or sent.
+
+```ruby
+# Disable tracing (useful for development/test environments)
+Simforge.configure(
+  api_key: ENV.fetch('SIMFORGE_API_KEY', 'dummy-key'),
+  enabled: false
+)
+```
+
+**Common patterns:**
+
+```ruby
+# Rails: Enable only in production
+Simforge.configure(
+  api_key: ENV.fetch('SIMFORGE_API_KEY', 'dummy-key'),
+  enabled: Rails.env.production?
+)
+
+# Environment variable control
+Simforge.configure(
+  api_key: ENV.fetch('SIMFORGE_API_KEY', 'dummy-key'),
+  enabled: ENV.fetch('SIMFORGE_ENABLED', 'false') == 'true'
+)
+
+# Multi-environment control
+Simforge.configure(
+  api_key: ENV.fetch('SIMFORGE_API_KEY', 'dummy-key'),
+  enabled: ['production', 'staging'].include?(ENV['RACK_ENV'])
+)
+```
+
+When `enabled: false`:
+- ✅ Code executes normally with no performance impact
+- ✅ Return values and errors work as expected
+- ✅ Nested spans are properly skipped
+- ❌ No HTTP requests are made
+- ❌ No span data is collected or sent
+
+## Usage
+
+### Class-Level Trace Function Key
+
+All spans in the class share the same trace function key:
+
+```ruby
+class PaymentService
+  include Simforge::Traceable
+  simforge_function "payment-processing"
+
+  simforge_span :charge_card, type: "function"
+  def charge_card(amount)
+    # Traced automatically
+  end
+
+  simforge_span :refund, type: "function"
+  def refund(transaction_id)
+    # Also uses "payment-processing" key
+  end
+end
+```
+
+### Per-Span Trace Function Key
+
+Each span can declare its own key:
+
+```ruby
+class NotificationService
+  include Simforge::Traceable
+
+  simforge_span :send_email, trace_function_key: "email-notifications", type: "function"
+  def send_email(to, subject)
+    # Uses "email-notifications" key
+  end
+
+  simforge_span :send_sms, trace_function_key: "sms-notifications", type: "function"
+  def send_sms(to, message)
+    # Uses "sms-notifications" key
+  end
+end
+```
+
+### Span Types
+
+Simforge supports the following span types:
+
+- `"llm"` - LLM API calls
+- `"agent"` - Agent decision loops
+- `"function"` - Business logic functions
+- `"guardrail"` - Validation and safety checks
+- `"handoff"` - Human-in-the-loop interactions
+- `"custom"` - Custom span types (default)
+
+```ruby
+simforge_span :validate_input, type: "guardrail"
+simforge_span :call_openai, type: "llm"
+simforge_span :agent_loop, type: "agent"
+```
+
+### Custom Span Names
+
+By default, the method name is used as the span name. Override it:
+
+```ruby
+simforge_span :process_order, name: "ProcessOrderV2", type: "function"
+def process_order(order_id)
+  # Span will be named "ProcessOrderV2"
+end
+```
+
+### Nested Spans
+
+Spans automatically track parent-child relationships:
+
+```ruby
+class OrderPipeline
+  include Simforge::Traceable
+  simforge_function "order-pipeline"
+
+  simforge_span :process, type: "function"
+  def process(order_id)
+    validate(order_id)
+    # More processing
+  end
+
+  simforge_span :validate, type: "guardrail"
+  def validate(order_id)
+    check_fraud(order_id)
+    # More validation
+  end
+
+  simforge_span :check_fraud, type: "guardrail"
+  def check_fraud(order_id)
+    # Fraud checking logic
+  end
+end
+
+# Creates 3 nested spans:
+# process (parent)
+#   └─ validate (child)
+#       └─ check_fraud (grandchild)
+```
+
+### Input/Output Capture
+
+Positional and keyword arguments are automatically captured:
+
+```ruby
+simforge_span :process_order, type: "function"
+def process_order(order_id, priority: :normal)
+  # Input captured: { "order_id" => "123", "priority" => "normal" }
+  { status: "completed" }
+  # Output captured: { "status" => "completed" }
+end
+```
+
+### Metadata
+
+Add custom metadata to spans:
+
+```ruby
+# Definition-time metadata
+simforge_span :process_order,
+  type: "function",
+  metadata: { "region" => "us-east", "version" => "v2" }
+def process_order(order_id)
+  # ...
+end
+
+# Runtime metadata (inside a span)
+simforge_span :process_order, type: "function"
+def process_order(order_id)
+  Simforge.current_span.add_metadata(
+    "user_id" => current_user.id,
+    "request_id" => request.id
+  )
+  # Runtime metadata merges with definition-time metadata
+end
+```
+
+### Wrapping External Code
+
+Wrap third-party library methods without modifying them:
+
+```ruby
+class ExternalHttpClient
+  def get(url)
+    # Third-party code
+  end
+end
+
+# Add tracing via wrap
+Simforge::Traceable.wrap(
+  ExternalHttpClient,
+  :get,
+  trace_function_key: "http-client",
+  type: "function"
+)
+
+# Now traced automatically
+client = ExternalHttpClient.new
+client.get("https://api.example.com")
+```
+
+### Error Handling
+
+Errors are automatically captured and re-raised:
+
+```ruby
+simforge_span :risky_operation, type: "function"
+def risky_operation
+  raise StandardError, "Something went wrong"
+end
+
+begin
+  service.risky_operation
+rescue StandardError => e
+  # Error is captured in span and re-raised
+  puts "Caught: #{e.message}"
+end
+```
+
+## Lifecycle
+
+### Automatic Flush
+
+Spans are sent in background threads and automatically flushed on exit via `at_exit` hook.
+
+### Manual Flush
+
+Wait for all pending spans to be sent:
+
+```ruby
+Simforge.flush_traces
+# Blocks until all background threads complete
+```
+
+### Reset Client
+
+Clear the global client (useful for testing):
+
+```ruby
+Simforge.reset!
+```
+
+## Thread Safety
+
+- Each thread has its own span context stack (using `Thread.current`)
+- Nested spans only work within the same thread
+- Background span sending is thread-safe
+
+## Examples
+
+See [simforge-ruby-example/](../simforge-ruby-example/) for complete working examples:
+
+- [test_span.rb](../simforge-ruby-example/scripts/test_span.rb) - Basic span creation
+- [test_nested_spans.rb](../simforge-ruby-example/scripts/test_nested_spans.rb) - Nested span hierarchies
+- [test_wrap.rb](../simforge-ruby-example/scripts/test_wrap.rb) - Wrapping external code
+- [test_enabled.rb](../simforge-ruby-example/scripts/test_enabled.rb) - Using the enabled flag
+- [test_metadata.rb](../simforge-ruby-example/scripts/test_metadata.rb) - Custom metadata
+
+## Development
+
+See [DEVELOPMENT.md](DEVELOPMENT.md) for development setup, testing, and publishing instructions.
+
+## License
+
+MIT

data/lib/simforge/client.rb

@@ -12,51 +12,86 @@ module Simforge
   class Client
     SPAN_TYPES = %w[llm agent function guardrail handoff custom].freeze
 
-    attr_reader :api_key, :service_url
+    attr_reader :api_key, :service_url, :enabled
 
-    def initialize(api_key:, service_url: nil)
+    def initialize(api_key:, service_url: nil, enabled: true)
       @api_key = api_key
       @service_url = service_url || DEFAULT_SERVICE_URL
+      @enabled = enabled
+      if @enabled && (@api_key.nil? || @api_key.to_s.strip.empty?)
+        warn "Simforge: api_key is empty — tracing is disabled. Provide a valid API key to enable tracing."
+        @enabled = false
+      end
       @http_client = HttpClient.new(api_key:, service_url: @service_url)
     end
 
     # Execute a block inside a span context, sending trace data on completion.
     # Called by Traceable — not intended for direct use.
     def execute_span(trace_function_key:, span_name:, span_type:, function_name:, args:, kwargs:)
-      validate_span_type!(span_type)
+      return yield unless @enabled
 
       parent = SpanContext.current
       trace_id = parent ? parent[:trace_id] : SecureRandom.uuid
       span_id = SecureRandom.uuid
       parent_span_id = parent&.dig(:span_id)
+      is_root_span = parent_span_id.nil?
       started_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
 
+      # Register trace state for root spans
+      if is_root_span && !TraceState.get(trace_id)
+        TraceState.create(trace_id)
+      end
+
       result = nil
       error = nil
+      span_contexts = nil
 
       begin
-        result = SpanContext.with_span(trace_id:, span_id:) { yield }
+        SpanContext.with_span(trace_id:, span_id:) do
+          result = yield
+        ensure
+          # Capture contexts before the span context is popped
+          span_contexts = SpanContext.current&.dig(:contexts)
+        end
       rescue => e
         error = e.message
         raise
       ensure
-        ended_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
-
-        send_span(
-          trace_function_key:,
-          trace_id:,
-          span_id:,
-          parent_span_id:,
-          span_name:,
-          span_type:,
-          function_name:,
-          args:,
-          kwargs:,
-          result:,
-          error:,
-          started_at:,
-          ended_at:
-        )
+        # Never crash the host app due to span building/sending
+        begin
+          ended_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
+
+          send_span(
+            trace_function_key:,
+            trace_id:,
+            span_id:,
+            parent_span_id:,
+            span_name:,
+            span_type:,
+            function_name:,
+            contexts: span_contexts,
+            args:,
+            kwargs:,
+            result:,
+            error:,
+            started_at:,
+            ended_at:
+          )
+
+          # For root spans, also send trace completion
+          if is_root_span
+            send_trace_completion(
+              trace_function_key:,
+              trace_id:,
+              started_at:,
+              ended_at:
+            )
+          end
+        rescue Exception # rubocop:disable Lint/RescueException
+          # Silently ignore — user's result/exception takes priority
+          # Catches Exception (not just StandardError) to handle SystemStackError
+          # from deeply nested serialization
+        end
       end
 
       result
@@ -70,8 +105,43 @@ module Simforge
       raise ArgumentError, "Invalid span type '#{type}'. Must be one of: #{SPAN_TYPES.join(", ")}"
     end
 
+    def send_trace_completion(trace_function_key:, trace_id:, started_at:, ended_at:)
+      trace_state = TraceState.get(trace_id)
+      trace_started_at = trace_state&.dig(:started_at) || started_at
+
+      raw_trace = {
+        "id" => trace_id,
+        "started_at" => trace_started_at,
+        "ended_at" => ended_at
+      }
+
+      if trace_state&.dig(:metadata)
+        raw_trace["metadata"] = trace_state[:metadata]
+      end
+      if trace_state&.dig(:contexts)
+        raw_trace["contexts"] = trace_state[:contexts]
+      end
+
+      payload = {
+        "type" => "sdk-function",
+        "source" => "ruby-sdk-function",
+        "traceFunctionKey" => trace_function_key,
+        "externalTrace" => raw_trace,
+        "completed" => true
+      }
+
+      if trace_state&.dig(:session_id)
+        payload["sessionId"] = trace_state[:session_id]
+      end
+
+      @http_client.send_external_trace(payload)
+
+      # Clean up trace state
+      TraceState.delete(trace_id)
+    end
+
     def send_span(trace_function_key:, trace_id:, span_id:, parent_span_id:,
-      span_name:, span_type:, function_name:, args:, kwargs:, result:, error:,
+      span_name:, span_type:, function_name:, contexts:, args:, kwargs:, result:, error:,
       started_at:, ended_at:)
       # Human-readable JSON (input/output fields)
       human_inputs = Serialize.serialize_inputs(args, kwargs)
@@ -92,6 +162,7 @@ module Simforge
       span_data["input_serialized"] = marshalled_input if marshalled_input
       span_data["output_serialized"] = marshalled_output if marshalled_output
       span_data["error"] = error if error
+      span_data["contexts"] = contexts if contexts&.any?
 
       raw_span = {
         "id" => span_id,

data/lib/simforge/http_client.rb

@@ -66,6 +66,15 @@ module Simforge
       end
     end
 
+    # Send an external trace (fire-and-forget in background thread).
+    def send_external_trace(payload)
+      merged = payload.merge("sdkVersion" => VERSION)
+
+      Simforge._run_in_background do
+        request("/api/sdk/externalTraces", merged, timeout: 10)
+      end
+    end
+
     private
 
     def headers

data/lib/simforge/span_context.rb

@@ -1,6 +1,86 @@
 # frozen_string_literal: true
 
 module Simforge
+  # Handle to the current active span, allowing context to be added.
+  class CurrentSpan
+    def initialize(span_state)
+      @span_state = span_state
+    end
+
+    # The trace ID for the current span.
+    def trace_id
+      @span_state[:trace_id]
+    end
+
+    # Add a context entry to this span.
+    # The entire hash is pushed as a single entry in the contexts array.
+    # Context entries are accumulated - multiple calls add to the list.
+    #
+    # @param context [Hash] key-value pairs to add as a single context entry
+    def add_context(context)
+      return unless context.is_a?(Hash)
+
+      @span_state[:contexts] ||= []
+      @span_state[:contexts] << context
+    rescue
+      # Silently ignore - never crash the host app
+    end
+  end
+
+  # Handle to the current active trace, allowing trace-level context to be set.
+  class CurrentTrace
+    def initialize(trace_id)
+      @trace_id = trace_id
+    end
+
+    # Set the session ID for this trace.
+    # Session ID is used to group traces from the same user session.
+    # This is stored as a database column.
+    #
+    # @param session_id [String] the session ID to set
+    def set_session_id(session_id)
+      trace_state = get_or_create_trace_state
+      trace_state[:session_id] = session_id
+    rescue
+      # Silently ignore - never crash the host app
+    end
+
+    # Set metadata for this trace.
+    # Metadata is stored in the raw trace data. Subsequent calls merge with
+    # existing metadata, with later values taking precedence.
+    #
+    # @param metadata [Hash] key-value pairs to store as trace metadata
+    def set_metadata(metadata)
+      return unless metadata.is_a?(Hash)
+
+      trace_state = get_or_create_trace_state
+      trace_state[:metadata] = (trace_state[:metadata] || {}).merge(metadata)
+    rescue
+      # Silently ignore - never crash the host app
+    end
+
+    # Add a context entry to this trace.
+    # The entire hash is pushed as a single entry in the contexts array.
+    # Context entries are accumulated - multiple calls add to the list.
+    #
+    # @param context [Hash] key-value pairs to add as a single context entry
+    def add_context(context)
+      return unless context.is_a?(Hash)
+
+      trace_state = get_or_create_trace_state
+      trace_state[:contexts] ||= []
+      trace_state[:contexts] << context
+    rescue
+      # Silently ignore - never crash the host app
+    end
+
+    private
+
+    def get_or_create_trace_state
+      TraceState.get(@trace_id) || TraceState.create(@trace_id)
+    end
+  end
+
   # Thread-local span stack for tracking nested spans.
   # Each entry is a Hash with :trace_id and :span_id keys.
   module SpanContext
@@ -26,4 +106,33 @@ module Simforge
       stack.pop
     end
   end
+
+  # Global storage for trace states (trace_id -> state hash)
+  module TraceState
+    @states_mutex = Mutex.new
+    @states = {}
+
+    module_function
+
+    def get(trace_id)
+      @states_mutex.synchronize { @states[trace_id] }
+    end
+
+    def create(trace_id)
+      @states_mutex.synchronize do
+        @states[trace_id] ||= {
+          trace_id:,
+          started_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
+        }
+      end
+    end
+
+    def delete(trace_id)
+      @states_mutex.synchronize { @states.delete(trace_id) }
+    end
+
+    def clear_all
+      @states_mutex.synchronize { @states.clear }
+    end
+  end
 end

data/lib/simforge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Simforge
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/simforge.rb

@@ -9,6 +9,37 @@ require_relative "simforge/client"
 require_relative "simforge/traceable"
 
 module Simforge
+  # No-op span handle returned when outside a span context.
+  # All methods do nothing, preventing crashes when called outside traced code.
+  class NoOpCurrentSpan
+    def trace_id
+      ""
+    end
+
+    def add_context(_context)
+      # No-op
+    end
+  end
+
+  # No-op trace handle returned when outside a span context.
+  # All methods do nothing, preventing crashes when called outside traced code.
+  class NoOpCurrentTrace
+    def set_session_id(_session_id)
+      # No-op
+    end
+
+    def set_metadata(_metadata)
+      # No-op
+    end
+
+    def add_context(_context)
+      # No-op
+    end
+  end
+
+  NO_OP_SPAN = NoOpCurrentSpan.new.freeze
+  NO_OP_TRACE = NoOpCurrentTrace.new.freeze
+
   class << self
     # Configure the global Simforge client.
     #
@@ -18,8 +49,8 @@ module Simforge
     # @example
     #   Simforge.configure(api_key: ENV["SIMFORGE_API_KEY"])
     #
-    def configure(api_key:, service_url: nil)
-      @client = Client.new(api_key:, service_url:)
+    def configure(api_key:, service_url: nil, enabled: true)
+      @client = Client.new(api_key:, service_url:, enabled:)
     end
 
     # Returns the global client, raising if not configured.
@@ -31,5 +62,31 @@ module Simforge
     def reset!
       @client = nil
     end
+
+    # Get a handle to the current active span.
+    #
+    # Call this from inside a traced method to get a span handle that allows
+    # setting metadata at runtime.
+    #
+    # @return [CurrentSpan, NoOpCurrentSpan] the current span, or a no-op if outside a span context
+    def current_span
+      entry = SpanContext.current
+      return NO_OP_SPAN unless entry
+
+      CurrentSpan.new(entry)
+    end
+
+    # Get a handle to the current active trace.
+    #
+    # Call this from inside a traced method to get a trace handle that allows
+    # setting trace-level context at runtime.
+    #
+    # @return [CurrentTrace, NoOpCurrentTrace] the current trace, or a no-op if outside a span context
+    def current_trace
+      entry = SpanContext.current
+      return NO_OP_TRACE unless entry
+
+      CurrentTrace.new(entry[:trace_id])
+    end
   end
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simforge
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Harvest Team
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-29 00:00:00.000000000 Z
+date: 2026-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -29,40 +30,68 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 description: Client library for sending function execution spans to the Simforge API.
@@ -73,6 +102,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/simforge.rb
 - lib/simforge/client.rb
 - lib/simforge/constants.rb
@@ -88,6 +118,7 @@ metadata:
   homepage_uri: https://simforge.goharvest.ai
   source_code_uri: https://simforge.goharvest.ai
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -102,7 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Simforge Ruby SDK for function tracing and span management
 test_files: []