observable 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08d7169aa0bffabba61651eb5fd9d5b798f0d17a3adbcc0406471d1138ca84c5'
-  data.tar.gz: e0ab04bad74667894f89368ca2f3bfedb3040a51010d6b62ee91beb63fcb84b4
+  metadata.gz: b257d27b8a651f747109ea43b983befa02c2e10d34d13a49cf025a5f46eb7592
+  data.tar.gz: '068c6c31c24e4473682c9d5072842d995cd43a0fae9dee2ca2749a7313bc69a5'
 SHA512:
-  metadata.gz: 244a0c1bf4902d735d38a51c236f0bbde64d63d27b630eb13d8ffe07436b56f4dff651707cd7bd5850bcabc851b024082f6077ee801b714f03a12eea762669bd
-  data.tar.gz: ac2f872738807294c54aa5e36c7c91760939dcf749066406e13bafd5053cf2b8acb74dc5535976556de513da7b2ecfadf9866a56c5bd267d9dfd80ce3a53d157
+  metadata.gz: 3d52b07648bd401f2494aa735e988a067c01bca1a443c1ee4ec609cebf582fc3eb3c59939c0b85a9880f0ad53a72b29495a249cea6bf92ee3dc8a114c674e340
+  data.tar.gz: eeb0349b60211293afe11f445789a3598e8ad2af6d577e53cf08958ec7237aa6c36799e047df11c0cb931ec6a960a085e14c2c96f79c5f504b6e0cf824ae03e2

data/.standard.yml

@@ -3,3 +3,5 @@
 ruby_version: 3.4
 fix: true
 parallel: true
+ignore:
+  - Gemfile.lock

data/CHANGELOG.md

@@ -1,5 +1,57 @@
 ## [Unreleased]
 
+
+
+
+
+## [0.1.4] - 2025-09-08
+
+### Changed
+- Update version bumping logic in bump script
+- v0.1.3-beta
+- Update gem build process and release script
+- v0.1.2-beta
+
+
+## [0.1.2-beta] - 2025-09-08
+
+### Changed
+- v0.1.2-beta
+
+
+## [0.1.2-alpha] - 2025-09-08
+
+### Added
+- Add support for bumping alpha and beta pre-releases
+
+### Changed
+- Update version bumping logic for bump gem
+- Delegate all version bumping to bump gem
+- Extract configuration into class
+- Update gemspec and test setup for OTLP exporter
+
+
+## [0.1.2-alpha] - 2025-09-08
+
+### Added
+- Add support for bumping alpha and beta pre-releases
+
+### Fixed
+- Update version to 0.1.2
+
+### Changed
+- Delegate all version bumping to bump gem
+- v0.1.2-alpha
+- Extract configuration into class
+- Update gemspec and test setup for OTLP exporter
+- Add 'ignore' section to configuration file
+
+
+## [0.1.2] - 2025-09-07
+
+### Changed
+- Add Ruby 3.2.x versions to GitHub Actions matrix for better CI coverage
+
 ## [0.1.0] - 2024-04-22
 
 - Initial release

data/CLAUDE.md

@@ -56,12 +56,34 @@ bin/console
 bundle exec rake build
 ```
 
-### Release Process
+### Version Management
 ```bash
-# Update version in lib/observable/version.rb
-bundle exec rake release
+# Bump patch version (0.1.1 -> 0.1.2)
+bin/bump
+
+# Bump minor version (0.1.1 -> 0.2.0)
+bin/bump --minor
+
+# Bump major version (0.1.1 -> 1.0.0)
+bin/bump --major
 ```
 
+### Release Process
+
+The project uses automated releases via GitHub Actions:
+
+1. **Manual Release**: Use `bin/bump` to increment version, update CHANGELOG.md, then commit and push to `main`
+2. **Automated Release**: When a version change is detected in a push to `main`, GitHub Actions will:
+   - Run tests across multiple Ruby versions
+   - Run linting checks
+   - Build the gem
+   - Create a GitHub release with changelog
+   - Publish to RubyGems (requires `RUBYGEMS_API_KEY` secret)
+
+**Prerequisites for automated release:**
+- Set `RUBYGEMS_API_KEY` secret in GitHub repository settings
+- Ensure CHANGELOG.md is updated with meaningful changes
+
 ## Configuration System
 
 The gem uses Dry::Configurable with these key settings:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    observable (0.1.1)
+    observable (0.1.4)
       dry-configurable (>= 0.13.0, < 2.0)
       dry-struct (~> 1.4)
       opentelemetry-sdk (~> 1.5)
@@ -10,8 +10,15 @@ GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.3)
+    attr_extras (7.1.0)
     bigdecimal (3.2.3)
+    bump (0.10.0)
     concurrent-ruby (1.3.5)
+    date (3.4.1)
+    debug (1.11.0)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    diff-lcs (1.6.2)
     docile (1.4.1)
     dry-configurable (1.3.0)
       dry-core (~> 1.1)
@@ -38,15 +45,40 @@ GEM
       dry-inflector (~> 1.0)
       dry-logic (~> 1.4)
       zeitwerk (~> 2.6)
+    erb (5.0.2)
+    google-protobuf (4.32.0)
+      bigdecimal
+      rake (>= 13)
+    google-protobuf (4.32.0-arm64-darwin)
+      bigdecimal
+      rake (>= 13)
+    googleapis-common-protos-types (1.21.0)
+      google-protobuf (~> 4.26)
     ice_nine (0.11.2)
+    io-console (0.8.1)
+    irb (1.15.2)
+      pp (>= 0.6.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
     json (2.13.2)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
+    m (1.6.2)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
+    method_source (1.1.0)
     minitest (5.25.5)
     opentelemetry-api (1.6.0)
     opentelemetry-common (0.22.0)
       opentelemetry-api (~> 1.0)
+    opentelemetry-exporter-otlp (0.30.0)
+      google-protobuf (>= 3.18)
+      googleapis-common-protos-types (~> 1.3)
+      opentelemetry-api (~> 1.1)
+      opentelemetry-common (~> 0.20)
+      opentelemetry-sdk (~> 1.2)
+      opentelemetry-semantic_conventions
     opentelemetry-registry (0.4.0)
       opentelemetry-api (~> 1.1)
     opentelemetry-sdk (1.8.1)
@@ -56,15 +88,29 @@ GEM
       opentelemetry-semantic_conventions
     opentelemetry-semantic_conventions (1.11.0)
       opentelemetry-api (~> 1.0)
+    optimist (3.2.1)
     parallel (1.27.0)
     parser (3.3.9.0)
       ast (~> 2.4.1)
       racc
+    patience_diff (1.2.0)
+      optimist (~> 3.0)
+    pp (0.6.2)
+      prettyprint
+    prettyprint (0.2.0)
     prism (1.4.0)
+    psych (5.2.6)
+      date
+      stringio
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.3.0)
+    rdoc (6.14.2)
+      erb
+      psych (>= 4.0.0)
     regexp_parser (2.11.2)
+    reline (0.6.2)
+      io-console (~> 0.5)
     rubocop (1.75.8)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
@@ -102,6 +148,11 @@ GEM
     standard-performance (1.8.0)
       lint_roller (~> 1.1)
       rubocop-performance (~> 1.25.0)
+    stringio (3.1.7)
+    super_diff (0.16.0)
+      attr_extras (>= 6.2.4)
+      diff-lcs
+      patience_diff
     unicode-display_width (3.1.5)
       unicode-emoji (~> 4.0, >= 4.0.4)
     unicode-emoji (4.0.4)
@@ -112,11 +163,16 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  bump (~> 0.10)
+  debug (~> 1.8)
+  m (~> 1.6)
   minitest (~> 5.14)
   observable!
+  opentelemetry-exporter-otlp (~> 0.30)
   rake (~> 13.0)
   simplecov (~> 0.22)
   standard (~> 1.40)
+  super_diff (~> 0.9)
 
 BUNDLED WITH
    2.6.3

data/lib/observable/configuration.rb

@@ -0,0 +1,17 @@
+require "dry/configurable"
+
+module Observable
+  class Configuration
+    extend Dry::Configurable
+
+    setting :tracer_name, default: "observable"
+    setting :transport, default: :otel
+    setting :app_namespace, default: "app"
+    setting :attribute_namespace, default: "app"
+    setting :formatters, default: {default: :to_h}
+    setting :pii_filters, default: []
+    setting :serialization_depth, default: {default: 2}
+    setting :track_return_values, default: true
+    setting :custom_error_converters, default: {}
+  end
+end

data/lib/observable/instrumenter.rb

@@ -1,22 +1,9 @@
 require "opentelemetry/sdk"
-require "dry/configurable"
+require_relative "configuration"
 
 module Observable
-  class Configuration
-    extend Dry::Configurable
-
-    setting :tracer_name, default: "observable"
-    setting :transport, default: :otel
-    setting :app_namespace, default: "app"
-    setting :attribute_namespace, default: "app"
-    setting :formatters, default: {default: :to_h}
-    setting :pii_filters, default: []
-    setting :serialization_depth, default: {default: 2}
-    setting :track_return_values, default: true
-  end
-
   class Instrumenter
-    attr_reader :last_captured_method_name, :last_captured_namespace, :config
+    attr_reader :last_captured_namespace, :config
 
     def initialize(tracer: nil, config: nil)
       @config = config || Configuration.config
@@ -31,7 +18,6 @@ module Observable
 
     private
 
-    # Extracts all information about the calling method in one place
     def extract_caller_information
       caller_location = find_caller_location
       namespace = extract_actual_class_name
@@ -105,17 +91,19 @@ module Observable
       separator = caller_info.is_class_method ? "." : "#"
 
       if caller_info.method_name.include?("#") || caller_info.method_name.include?(".")
-        span_name = caller_info.method_name
+        span_name = "#{caller_info.namespace}#{separator}#{caller_info.method_name.split(/[#.]/).last}"
+        function_name = "#{caller_info.namespace}#{separator}#{caller_info.method_name.split(/[#.]/).last}"
         method_name_only = caller_info.method_name.split(/[#.]/).last
       else
         span_name = "#{caller_info.namespace}#{separator}#{caller_info.method_name}"
+        function_name = "#{caller_info.namespace}#{separator}#{caller_info.method_name}"
         method_name_only = caller_info.method_name
       end
 
       @last_captured_method_name = method_name_only
       @last_captured_namespace = caller_info.namespace
       @tracer.in_span(span_name) do |span|
-        set_span_attributes(span, caller_info)
+        set_span_attributes(span, caller_info, function_name)
 
         begin
           result = block.call
@@ -124,16 +112,20 @@ module Observable
           result
         rescue => e
           span.set_attribute("error", true)
-          span.set_attribute("error.type", e.class.name)
-          span.set_attribute("error.message", e.message)
+          span.set_attribute("exception.type", e.respond_to?(:type) ? e.type : e.class.name)
+          span.set_attribute("exception.message", e.message)
+          span.set_attribute("exception.stacktrace", e.full_message(highlight: false))
+          latest_backtrace_line = e.backtrace.find { |line| line.include?(caller_info.filepath) }
+          span.set_attribute("code.lineno", latest_backtrace_line.split(":")[1].to_i) if latest_backtrace_line
+          serialize_argument(span, "exception.context", e.to_h.except(:message)) if e.respond_to?(:to_h)
           span.status = OpenTelemetry::Trace::Status.error(e.message)
           raise
         end
       end
     end
 
-    def set_span_attributes(span, caller_info)
-      span.set_attribute("code.function", caller_info.method_name)
+    def set_span_attributes(span, caller_info, function_name)
+      span.set_attribute("code.function", function_name)
       span.set_attribute("code.namespace", caller_info.namespace)
       span.set_attribute("code.filepath", caller_info.filepath)
       span.set_attribute("code.lineno", caller_info.line_number)
@@ -158,8 +150,10 @@ module Observable
       end
 
       case value
-      when String, Numeric, TrueClass, FalseClass, NilClass
+      when String, Numeric, TrueClass, FalseClass
         span.set_attribute(attribute_prefix, value)
+      when NilClass
+        span.set_attribute(attribute_prefix, "nil")
       when Hash
         serialize_hash(span, attribute_prefix, value, depth)
       when Array

data/lib/observable/persistence/span.rb

@@ -0,0 +1,119 @@
+require "dry-struct"
+
+module Observable
+  module Persistence
+    class Span < Dry::Struct
+      attribute :id, Dry.Types::String
+      attribute :name, Dry.Types::String
+      attribute :kind, Dry.Types::Symbol
+      attribute :trace_id, Dry.Types::String
+      attribute :attrs, Dry.Types::Hash
+
+      # ANSI Color constants
+      RESET = "\e[0m"
+      BOLD = "\e[1m"
+      DIM = "\e[2m"
+      CYAN = "\e[36m"
+      YELLOW = "\e[33m"
+      GREEN = "\e[32m"
+      BLUE = "\e[34m"
+      MAGENTA = "\e[35m"
+      WHITE = "\e[37m"
+
+      def hex_trace_id
+        trace_id
+      end
+
+      def hex_span_id
+        id
+      end
+
+      def code_namespace
+        attrs["code.namespace"] || attrs["messaging.sidekiq.job_class"] || ""
+      end
+
+      def producer?
+        kind == :producer
+      end
+
+      def consumer?
+        kind == :consumer
+      end
+
+      def self.from_spandata(span_or_spandata)
+        new(
+          id: span_or_spandata.hex_span_id,
+          trace_id: span_or_spandata.hex_trace_id,
+          name: span_or_spandata.name,
+          kind: span_or_spandata.kind,
+          attrs: span_or_spandata.attributes
+        )
+      end
+
+      def self.from_span_or_spandata(span_or_spandata)
+        if span_or_spandata.is_a?(Span)
+          span_or_spandata
+        else
+          from_spandata(span_or_spandata)
+        end
+      end
+
+      def inspect
+        ai
+      end
+
+      def ai
+        output = []
+        output << "  #{colorize(name, CYAN, BOLD)}"
+        output << "  id: #{colorize(id, WHITE)}"
+
+        if attrs.any?
+          attrs.each do |key, value|
+            output << "    #{colorize(key, YELLOW)}: #{colorize_value(value)}"
+          end
+        end
+
+        output << ""
+        output.join("\n")
+      end
+
+      private
+
+      def colorize(text, color, style = nil)
+        if style
+          "#{color}#{style}#{text}#{RESET}"
+        else
+          "#{color}#{text}#{RESET}"
+        end
+      end
+
+      def colorize_kind(kind)
+        case kind.to_s
+        when "internal"
+          colorize(kind, GREEN)
+        when "producer"
+          colorize(kind, BLUE)
+        when "consumer"
+          colorize(kind, MAGENTA)
+        else
+          colorize(kind, WHITE)
+        end
+      end
+
+      def colorize_value(value)
+        case value
+        when String
+          colorize("\"#{value}\"", GREEN)
+        when Numeric
+          colorize(value.to_s, BLUE)
+        when TrueClass, FalseClass
+          colorize(value.to_s, MAGENTA)
+        when NilClass
+          colorize("null", DIM)
+        else
+          colorize(value.inspect, WHITE)
+        end
+      end
+    end
+  end
+end

data/lib/observable/persistence/span_repo.rb

@@ -0,0 +1,142 @@
+require_relative "span"
+
+module Observable
+  module Persistence
+    class SpanRepo
+      include Enumerable
+
+      def initialize(spans:)
+        @spans = spans.map { |span_or_spandata| Span.from_span_or_spandata(span_or_spandata) }
+      end
+
+      def each(&)
+        @spans.each(&)
+      end
+
+      def in_code_namespace(namespace)
+        select { |span| span.code_namespace == namespace }
+      end
+
+      def in_root_trace
+        result = group_by(&:trace_id).find { |_trace_id, spans| spans.count > 1 }
+        if result
+          self.class.new(spans: result.last)
+        else
+          self.class.new(spans: [])
+        end
+      end
+
+      def one_and_only!
+        if one?
+          first
+        else
+          raise ArgumentError, "Expected 1 span, but found #{count}: #{to_a}"
+        end
+      end
+
+      def find_one!(attrs: {}, &block)
+        block = to_block(attrs) if attrs.any? && !block_given?
+
+        if one?(&block)
+          find(&block)
+        elsif empty?(&block)
+          raise_none_found
+        else
+          raise_too_many_found(&block)
+        end
+      end
+
+      def empty?(&)
+        count(&).zero?
+      end
+
+      def raise_none_found
+        raise ArgumentError, "No spans found"
+      end
+
+      def raise_too_many_found(&)
+        matched = select(&)
+        raise ArgumentError, "Too many spans found:\n#{matched.inspect}"
+      end
+
+      def find_by!(name:)
+        span = find { |s| s.name == name }
+        span || raise(Observable::NotFound, "No spans found with name: #{name}\n\nSpans:\n#{ai}")
+      end
+
+      def find_by_attrs!(attrs)
+        span = find { |s| matches_criteria?(s, attrs) }
+        span || raise(Observable::NotFound, "No spans found with attributes: #{attrs}\n\nSpans:\n#{ai}")
+      end
+
+      def where(criteria)
+        matching_spans = select { |span| matches_criteria?(span, criteria) }
+        self.class.new(spans: matching_spans)
+      end
+
+      def to_block(query)
+        lambda do |object|
+          object.attrs.transform_keys(&:to_s).slice(*query.transform_keys(&:to_s).keys) == query.transform_keys(&:to_s)
+        end
+      end
+
+      def inspect
+        ai
+      end
+
+      def ai
+        grouped_spans = group_by(&:trace_id)
+        output = []
+
+        grouped_spans.each do |trace_id, spans|
+          output << colorize_trace_header(trace_id)
+          spans.each do |span|
+            output << span.ai
+          end
+        end
+
+        output.join("\n")
+      end
+
+      private
+
+      def matches_criteria?(span, criteria)
+        criteria.all? do |key, expected_value|
+          if expected_value.is_a?(Hash)
+            # Handle nested hash syntax like {code: {return: "hello"}}
+            nested_hash = get_value(span.attrs, key)
+            return false unless nested_hash.is_a?(Hash)
+            expected_value.all? do |nested_key, nested_value|
+              get_value(nested_hash, nested_key) == nested_value
+            end
+          else
+            # Handle simple keys and dot notation
+            get_value(span.attrs, key) == expected_value
+          end
+        end
+      end
+
+      def get_value(hash, key)
+        if key.is_a?(String) && key.include?(".")
+          # Handle dot notation like "code.return"
+          key.split(".").reduce(hash) do |current_hash, nested_key|
+            return nil unless current_hash.is_a?(Hash)
+            current_hash[nested_key] || current_hash[nested_key.to_s]
+          end
+        else
+          # Handle simple keys (try both symbol and string)
+          hash[key] || hash[key.to_s]
+        end
+      end
+
+      def colorize_trace_header(trace_id)
+        # Use the same color constants from Span
+        cyan = "\e[36m"
+        bold = "\e[1m"
+        reset = "\e[0m"
+
+        "#{cyan}#{bold}#{trace_id}#{reset}"
+      end
+    end
+  end
+end

data/lib/observable/persistence/trace.rb

@@ -0,0 +1,22 @@
+require "dry-struct"
+require_relative "span"
+
+module Observable
+  module Persistence
+    class Trace < Dry::Struct
+      attribute :id, Dry.Types::String
+      attribute :spans, Dry.Types::Array.of(Span)
+
+      def self.from_id_and_spandatas(id:, spandatas:)
+        new(
+          id: id,
+          spans: spandatas.map { |spandata| Span.from_spandata(spandata) }
+        )
+      end
+
+      def root?
+        spans.count > 1
+      end
+    end
+  end
+end

data/lib/observable/persistence/trace_repo.rb

@@ -0,0 +1,43 @@
+require_relative "trace"
+
+module Observable
+  module Persistence
+    class TraceRepo
+      include Enumerable
+
+      def initialize(spans:)
+        @traces = spans.group_by(&:hex_trace_id).map { |id, spandatas| Trace.from_id_and_spandatas(id:, spandatas:) }
+      end
+
+      def each(&block)
+        @traces.each(&block)
+      end
+
+      def root!
+        find_one!(&:root?)
+      end
+
+      def empty?(&block)
+        count(&block).zero?
+      end
+
+      def find_one!(&block)
+        if one?(&block)
+          find(&block)
+        elsif empty?(&block)
+          raise_none_found
+        else
+          raise_too_many_found
+        end
+      end
+
+      def raise_none_found
+        raise ArgumentError, "No traces found"
+      end
+
+      def raise_too_many_found
+        raise ArgumentError, "Multiple traces found"
+      end
+    end
+  end
+end

data/lib/observable/structured_error.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Observable
+  class StructuredError < StandardError
+    attr_reader :context, :type
+
+    def initialize(message, type: self.class.name, context: {})
+      @context = context.to_h
+      @type = (type || self.class.name).to_s
+      super(message)
+    end
+
+    def to_h
+      {message: message}.merge(@context)
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{message}, type=#{type}, context=#{@context}>"
+    end
+
+    def pretty_print
+      "#<#{self.class.name}: message: #{message}, type: #{type}, context: #{@context}>"
+    end
+
+    def self.from_error(error)
+      custom_converter_result = try_custom_converter(error)
+      if custom_converter_result
+        new(
+          custom_converter_result[:message],
+          type: custom_converter_result[:type],
+          context: custom_converter_result[:context]
+        )
+      else
+        new(
+          safe_message(error),
+          type: safe_type(error),
+          context: safe_context(error)
+        )
+      end
+    end
+
+    def self.safe_message(error)
+      if error.respond_to?(:message)
+        error.message.to_s
+      else
+        ""
+      end
+    rescue
+      ""
+    end
+
+    def self.safe_type(error)
+      return "NilClass" if error.nil?
+
+      if error.respond_to?(:type)
+        type_value = error.type
+        return type_value.to_s unless type_value.nil? || type_value.to_s.empty?
+      end
+
+      if error.respond_to?(:name)
+        name_value = error.name
+        return name_value.to_s unless name_value.nil? || name_value.to_s.empty?
+      end
+
+      error.class.name
+    rescue
+      error.class.name
+    end
+
+    def self.safe_context(error)
+      if error.nil?
+        {}
+      elsif error.respond_to?(:to_h)
+        error.to_h
+      elsif error.respond_to?(:context)
+        error.context
+      else
+        {}
+      end
+    rescue
+      {}
+    end
+
+    def self.try_custom_converter(error)
+      return nil if error.nil?
+
+      converters = Configuration.config.custom_error_converters
+      return nil if converters.empty?
+
+      converter = converters[error.class.name]
+      return nil unless converter
+
+      result = begin
+        converter.call(error)
+      rescue
+        nil
+      end
+
+      if result&.is_a?(Hash) &&
+          result.key?(:message) &&
+          result.key?(:type) &&
+          result.key?(:context)
+        result
+      end
+    end
+
+    private_class_method :safe_message, :safe_type, :safe_context, :try_custom_converter
+  end
+end

data/lib/observable/tracing_test_helper.rb

@@ -0,0 +1,51 @@
+require_relative "persistence/trace_repo"
+require_relative "persistence/span_repo"
+
+module Observable
+  module TracingTestHelper
+    def traces
+      Observable::Persistence::TraceRepo.new(spans: finished_spans)
+    end
+
+    def spans
+      Observable::Persistence::SpanRepo.new(spans: finished_spans)
+    end
+
+    def setup_observable_data!
+      @open_telemetry_exporter = setup_opentelemetry_for_tests
+    end
+
+    def teardown_observable_data!
+      reset_observable_data!
+      @open_telemetry_exporter = nil
+    end
+
+    def reset_observable_data!
+      raise NoOpenTelemetryExporter if @open_telemetry_exporter.nil?
+
+      @open_telemetry_exporter.reset
+    end
+
+    private
+
+    def finished_spans
+      raise NoOpenTelemetryExporter if @open_telemetry_exporter.nil?
+
+      @open_telemetry_exporter.finished_spans
+    end
+
+    def setup_opentelemetry_for_tests
+      require "opentelemetry/sdk"
+
+      exporter = OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.new
+      span_processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter)
+
+      # Configure the tracer provider with our span processor
+      tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new
+      tracer_provider.add_span_processor(span_processor)
+      OpenTelemetry.tracer_provider = tracer_provider
+
+      exporter
+    end
+  end
+end

data/lib/observable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Observable
-  VERSION = "0.1.1"
+  VERSION = "0.1.4"
 end

data/lib/observable.rb

@@ -1,13 +1,30 @@
 # frozen_string_literal: true
 
 require_relative "observable/version"
+require_relative "observable/configuration"
 require_relative "observable/instrumenter"
+require_relative "observable/structured_error"
+require_relative "observable/persistence/span"
+require_relative "observable/persistence/span_repo"
+require_relative "observable/persistence/trace"
+require_relative "observable/persistence/trace_repo"
 
 module Observable
   class Error < StandardError; end
 
-  # Convenience method to create a new instrumenter instance
+  class NoOpenTelemetryExporter < Error
+    def message
+      "No OpenTelemetry exporter set up. Call `Observable::TracingTestHelper#use_in_memory_otel_exporter!` to set up the exporter."
+    end
+  end
+
+  class NotFound < Error; end
+
   def self.instrumenter(config: nil)
     Instrumenter.new(config: config)
   end
+
+  def self.configure
+    yield Configuration.config
+  end
 end

data/observable.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "A Ruby gem that provides automated OpenTelemetry instrumentation for method calls with configurable serialization, PII filtering, and argument tracking"
   spec.homepage = "https://github.com/JoyfulProgramming/observable"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
@@ -37,11 +37,13 @@ Gem::Specification.new do |spec|
   spec.add_dependency "dry-struct", "~> 1.4"
 
   # Development dependencies
+  spec.add_development_dependency "m", "~> 1.6"
+  spec.add_development_dependency "bump", "~> 0.10"
   spec.add_development_dependency "minitest", "~> 5.14"
+  spec.add_development_dependency "opentelemetry-exporter-otlp", "~> 0.30"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "simplecov", "~> 0.22"
   spec.add_development_dependency "standard", "~> 1.40"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_development_dependency "super_diff", "~> 0.9"
+  spec.add_development_dependency "debug", "~> 1.8"
 end

data/pretty.rb

@@ -0,0 +1,12 @@
+require "pp"
+
+data = {
+  users: [
+    {name: "Alice", email: "alice@example.com", roles: ["admin", "user"], active: true, created_at: Time.now},
+    {name: "Bob", email: "bob@example.com", roles: ["user"], active: false, created_at: Time.now},
+    {name: "Charlie", email: "charlie@example.com", roles: ["moderator", "user"], active: true, created_at: Time.now}
+  ],
+  settings: {theme: "dark", notifications: true, language: "en"}
+}
+
+puts data

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: observable
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - John Gallagher
 bindir: exe
 cert_chain: []
-date: 2025-09-07 00:00:00.000000000 Z
+date: 2025-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-sdk
@@ -57,6 +57,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: bump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -71,6 +99,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.14'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -113,6 +155,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.40'
+- !ruby/object:Gem::Dependency
+  name: super_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 description: A Ruby gem that provides automated OpenTelemetry instrumentation for
   method calls with configurable serialization, PII filtering, and argument tracking
 email:
@@ -134,9 +204,17 @@ files:
 - Rakefile
 - example.rb
 - lib/observable.rb
+- lib/observable/configuration.rb
 - lib/observable/instrumenter.rb
+- lib/observable/persistence/span.rb
+- lib/observable/persistence/span_repo.rb
+- lib/observable/persistence/trace.rb
+- lib/observable/persistence/trace_repo.rb
+- lib/observable/structured_error.rb
+- lib/observable/tracing_test_helper.rb
 - lib/observable/version.rb
 - observable.gemspec
+- pretty.rb
 - sig/observable.rbs
 homepage: https://github.com/JoyfulProgramming/observable
 licenses:
@@ -153,7 +231,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="