braintrust 0.0.12 → 0.1.0

data/lib/braintrust/contrib/setup.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "../internal/env"
+
+module Braintrust
+  module Contrib
+    # Automatic instrumentation setup for LLM libraries.
+    #
+    # Intercepts `require` calls to detect when LLM libraries are loaded, then patches
+    # them automatically. The main challenge is doing this safely with zeitwerk (Rails'
+    # autoloader) which also hooks into require.
+    #
+    # ## The Zeitwerk Problem
+    #
+    # Zeitwerk uses `alias_method :zeitwerk_original_require, :require`. If we prepend
+    # to Kernel before zeitwerk loads, zeitwerk captures our method as its "original",
+    # creating an infinite loop.
+    #
+    # ## Solution: Two-Phase Hook
+    #
+    #   ┌─────────────────────────────────────────────────────────────────────────┐
+    #   │                         Setup.run! called                               │
+    #   └─────────────────────────────────────────────────────────────────────────┘
+    #                                      │
+    #            ┌─────────────────────────┼─────────────────────────┐
+    #            ▼                         ▼                         ▼
+    #   ┌─────────────────┐     ┌─────────────────────┐    ┌─────────────────────┐
+    #   │ Rails loaded?   │     │ Zeitwerk loaded?    │    │ Neither loaded yet  │
+    #   │ (Rails::Railtie)│     │                     │    │                     │
+    #   └────────┬────────┘     └──────────┬──────────┘    └──────────┬──────────┘
+    #            │                         │                          │
+    #            ▼                         ▼                          ▼
+    #   ┌─────────────────┐     ┌─────────────────────┐    ┌─────────────────────┐
+    #   │ Install Railtie │     │ Install prepend     │    │ Install watcher     │
+    #   │ (after_init)    │     │ hook directly       │    │ hook (alias_method) │
+    #   └─────────────────┘     └─────────────────────┘    └──────────┬──────────┘
+    #            │                         │                          │
+    #            │                         │               ┌──────────┴──────────┐
+    #            │                         │               ▼                     ▼
+    #            │                         │      ┌──────────────┐    ┌──────────────────┐
+    #            │                         │      │ Rails loads? │    │ Zeitwerk loads?  │
+    #            │                         │      │ → Railtie    │    │ → Prepend hook   │
+    #            │                         │      └──────────────┘    └──────────────────┘
+    #            │                         │               │                     │
+    #            ▼                         ▼               ▼                     ▼
+    #   ┌─────────────────────────────────────────────────────────────────────────┐
+    #   │                    LLM library loads → patch!                           │
+    #   └─────────────────────────────────────────────────────────────────────────┘
+    #
+    # The watcher hook uses alias_method which zeitwerk captures harmlessly (alias
+    # chains work correctly). Once zeitwerk/Rails loads, we upgrade to the better
+    # approach: prepend (takes precedence, `super` chains through zeitwerk) or
+    # Railtie (patches after all gems loaded via after_initialize).
+    #
+    module Setup
+      REENTRANCY_KEY = :braintrust_in_require_hook
+
+      class << self
+        # Main entry point. Call once per process.
+        def run!
+          unless Internal::Env.auto_instrument
+            Braintrust::Log.debug("Contrib::Setup: auto-instrumentation disabled via environment")
+            return
+          end
+
+          @registry = Contrib::Registry.instance
+          @only = Internal::Env.instrument_only
+          @except = Internal::Env.instrument_except
+
+          if defined?(::Rails::Railtie)
+            Braintrust::Log.debug("Contrib::Setup: using Rails railtie hook")
+            install_railtie!
+          elsif defined?(::Zeitwerk)
+            Braintrust::Log.debug("Contrib::Setup: using require hook (zeitwerk detected)")
+            install_require_hook!
+          else
+            Braintrust::Log.debug("Contrib::Setup: using watcher hook")
+            install_watcher_hook!
+          end
+        end
+
+        # Called after each require to check if we should patch anything.
+        def on_require(path)
+          return unless @registry
+
+          @registry.integrations_for_require_path(path).each do |integration|
+            next unless integration.available? && integration.compatible?
+            next if @only && !@only.include?(integration.integration_name)
+            next if @except&.include?(integration.integration_name)
+
+            Braintrust::Log.debug("Contrib::Setup: patching #{integration.integration_name}")
+            integration.patch!
+          end
+        rescue => e
+          Braintrust::Log.error("Auto-instrument failed: #{e.message}")
+        end
+
+        # Execute block with reentrancy protection (prevents infinite loops).
+        def with_reentrancy_guard
+          return if Thread.current[REENTRANCY_KEY]
+          Thread.current[REENTRANCY_KEY] = true
+          yield
+        rescue => e
+          Braintrust::Log.error("Auto-instrument failed: #{e.message}")
+        ensure
+          Thread.current[REENTRANCY_KEY] = false
+        end
+
+        def railtie_installed? = @railtie_installed
+        def require_hook_installed? = @require_hook_installed
+
+        def install_railtie!
+          return if @railtie_installed
+          @railtie_installed = true
+          require_relative "rails/railtie"
+        end
+
+        def install_require_hook!
+          return if @require_hook_installed
+          @require_hook_installed = true
+          Kernel.prepend(RequireHook)
+        end
+
+        private
+
+        def install_watcher_hook!
+          return if Kernel.private_method_defined?(:braintrust_watcher_require)
+
+          Kernel.module_eval do
+            alias_method :braintrust_watcher_require, :require
+
+            define_method(:require) do |path|
+              result = braintrust_watcher_require(path)
+
+              # Detect Rails/zeitwerk loading and upgrade hook strategy.
+              # IMPORTANT: Only check when the gem itself finishes loading (path match),
+              # not on every require where the constant happens to be defined.
+              # Installing too early (during gem init) breaks the alias_method chain.
+              if (path == "rails" || path.include?("railties")) &&
+                  defined?(::Rails::Railtie) && !Braintrust::Contrib::Setup.railtie_installed?
+                Braintrust::Contrib::Setup.install_railtie!
+              elsif (path == "zeitwerk" || path.end_with?("/zeitwerk.rb")) &&
+                  defined?(::Zeitwerk) && !Braintrust::Contrib::Setup.require_hook_installed?
+                Braintrust::Contrib::Setup.install_require_hook!
+              end
+
+              Braintrust::Contrib::Setup.with_reentrancy_guard do
+                Braintrust::Contrib::Setup.on_require(path)
+              end
+
+              result
+            end
+          end
+        end
+      end
+    end
+
+    # Prepend module for require interception.
+    # Only installed AFTER zeitwerk loads to avoid alias_method loop.
+    module RequireHook
+      def require(path)
+        result = super
+        Setup.with_reentrancy_guard { Setup.on_require(path) }
+        result
+      end
+    end
+  end
+end

data/lib/braintrust/contrib/support/openai.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Braintrust
+  module Contrib
+    module Support
+      # OpenAI API-specific utilities shared across OpenAI integrations.
+      # These work with normalized data structures (hashes), not library-specific objects.
+      module OpenAI
+        # Parse OpenAI usage tokens into normalized Braintrust metrics.
+        # Handles standard fields and *_tokens_details nested objects.
+        # Works with both Hash objects and SDK response objects (via to_h).
+        # @param usage [Hash, Object] usage object from OpenAI response
+        # @return [Hash<String, Integer>] normalized metrics
+        def self.parse_usage_tokens(usage)
+          metrics = {}
+          return metrics unless usage
+
+          usage_hash = usage.respond_to?(:to_h) ? usage.to_h : usage
+          return metrics unless usage_hash.is_a?(Hash)
+
+          # Field mappings: OpenAI → Braintrust
+          # Supports both Chat Completions API (prompt_tokens, completion_tokens)
+          # and Responses API (input_tokens, output_tokens)
+          field_map = {
+            "prompt_tokens" => "prompt_tokens",
+            "completion_tokens" => "completion_tokens",
+            "total_tokens" => "tokens",
+            # Responses API uses different field names
+            "input_tokens" => "prompt_tokens",
+            "output_tokens" => "completion_tokens"
+          }
+
+          # Prefix mappings for *_tokens_details
+          prefix_map = {
+            "prompt" => "prompt",
+            "completion" => "completion",
+            # Responses API uses input/output prefixes
+            "input" => "prompt",
+            "output" => "completion"
+          }
+
+          usage_hash.each do |key, value|
+            key_str = key.to_s
+
+            if value.is_a?(Numeric)
+              target = field_map[key_str]
+              metrics[target] = value.to_i if target
+            elsif key_str.end_with?("_tokens_details")
+              # Convert to hash if it's an object (OpenAI SDK returns objects)
+              details_hash = value.respond_to?(:to_h) ? value.to_h : value
+              next unless details_hash.is_a?(Hash)
+
+              raw_prefix = key_str.sub(/_tokens_details$/, "")
+              prefix = prefix_map[raw_prefix] || raw_prefix
+              details_hash.each do |detail_key, detail_value|
+                next unless detail_value.is_a?(Numeric)
+                metrics["#{prefix}_#{detail_key}"] = detail_value.to_i
+              end
+            end
+          end
+
+          # Calculate total if missing
+          if !metrics.key?("tokens") && metrics.key?("prompt_tokens") && metrics.key?("completion_tokens")
+            metrics["tokens"] = metrics["prompt_tokens"] + metrics["completion_tokens"]
+          end
+
+          metrics
+        end
+      end
+    end
+  end
+end

data/lib/braintrust/contrib/support/otel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Braintrust
+  module Contrib
+    module Support
+      # OpenTelemetry utilities shared across all integrations.
+      module OTel
+        # Helper to safely set a JSON attribute on a span
+        # Only sets the attribute if obj is present
+        # @param span [OpenTelemetry::Trace::Span] the span to set attribute on
+        # @param attr_name [String] the attribute name (e.g., "braintrust.output_json")
+        # @param obj [Object] the object to serialize to JSON
+        # @return [void]
+        def self.set_json_attr(span, attr_name, obj)
+          return unless obj
+          span.set_attribute(attr_name, JSON.generate(obj))
+        end
+      end
+    end
+  end
+end

data/lib/braintrust/contrib.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative "contrib/registry"
+require_relative "contrib/integration"
+require_relative "contrib/patcher"
+require_relative "contrib/context"
+
+module Braintrust
+  # Auto-instrument available integrations.
+  #
+  # Discovers which integrations have their target libraries loaded
+  # and instruments them automatically. This is the primary public API
+  # for enabling auto-instrumentation.
+  #
+  # @param config [nil, Boolean, Hash] Auto-instrumentation configuration:
+  #   - nil: use BRAINTRUST_AUTO_INSTRUMENT env var (defaults to enabled)
+  #   - true: explicitly enable auto-instrumentation
+  #   - false: explicitly disable auto-instrumentation
+  #   - Hash with :only or :except keys for filtering integrations
+  #
+  # Environment variables:
+  #   - BRAINTRUST_AUTO_INSTRUMENT: set to "false" to disable (default: enabled)
+  #   - BRAINTRUST_INSTRUMENT_ONLY: comma-separated list of integrations to include
+  #   - BRAINTRUST_INSTRUMENT_EXCEPT: comma-separated list of integrations to exclude
+  #
+  # @return [Array<Symbol>, nil] names of instrumented integrations, or nil if disabled
+  #
+  # @example Enable with defaults
+  #   Braintrust.auto_instrument!
+  #
+  # @example Explicitly enable
+  #   Braintrust.auto_instrument!(true)
+  #
+  # @example Disable
+  #   Braintrust.auto_instrument!(false)
+  #
+  # @example Only specific integrations
+  #   Braintrust.auto_instrument!(only: [:openai, :anthropic])
+  #
+  # @example Exclude specific integrations
+  #   Braintrust.auto_instrument!(except: [:ruby_llm])
+  def self.auto_instrument!(config = nil)
+    should_instrument = case config
+    when nil
+      Internal::Env.auto_instrument
+    when false
+      false
+    when true, Hash
+      true
+    end
+
+    return unless should_instrument
+
+    only = Internal::Env.instrument_only
+    except = Internal::Env.instrument_except
+
+    if config.is_a?(Hash)
+      only = config[:only] || only
+      except = config[:except] || except
+    end
+
+    Contrib.auto_instrument!(only: only, except: except)
+  end
+
+  # Instrument a registered integration by name.
+  # This is the main entry point for activating integrations.
+  #
+  # @param name [Symbol] The integration name (e.g., :openai, :anthropic)
+  # @param options [Hash] Optional configuration
+  # @option options [Object] :target Optional target instance to instrument specifically
+  # @option options [OpenTelemetry::SDK::Trace::TracerProvider] :tracer_provider Optional tracer provider
+  # @return [void]
+  #
+  # @example Instrument all OpenAI clients
+  #   Braintrust.instrument!(:openai)
+  #
+  # @example Instrument specific OpenAI client instance
+  #   client = OpenAI::Client.new
+  #   Braintrust.instrument!(:openai, target: client, tracer_provider: my_provider)
+  def self.instrument!(name, **options)
+    Contrib.instrument!(name, **options)
+  end
+
+  # Contrib framework for auto-instrumentation integrations.
+  # Provides a consistent interface for all integrations and enables
+  # reliable auto-instrumentation in later milestones.
+  module Contrib
+    class << self
+      # Get the global registry instance.
+      # @return [Registry]
+      def registry
+        Registry.instance
+      end
+
+      # Initialize the contrib framework with optional configuration.
+      # @param tracer_provider [OpenTelemetry::SDK::Trace::TracerProvider, nil] Optional tracer provider
+      # @return [void]
+      def init(tracer_provider: nil)
+        @default_tracer_provider = tracer_provider
+      end
+
+      # Auto-instrument available integrations.
+      # Discovers which integrations have their target libraries loaded
+      # and instruments them automatically.
+      #
+      # @param only [Array<Symbol>] whitelist - only instrument these
+      # @param except [Array<Symbol>] blacklist - skip these
+      # @return [Array<Symbol>] names of integrations that were instrumented
+      #
+      # @example Instrument all available
+      #   Braintrust::Contrib.auto_instrument!
+      #
+      # @example Only specific integrations
+      #   Braintrust::Contrib.auto_instrument!(only: [:openai, :anthropic])
+      #
+      # @example Exclude specific integrations
+      #   Braintrust::Contrib.auto_instrument!(except: [:ruby_llm])
+      def auto_instrument!(only: nil, except: nil)
+        if only || except
+          Braintrust::Log.debug("auto_instrument! called (only: #{only.inspect}, except: #{except.inspect})")
+        else
+          Braintrust::Log.debug("auto_instrument! called")
+        end
+
+        targets = registry.available
+        Braintrust::Log.debug("auto_instrument! available: #{targets.map(&:integration_name).inspect}")
+        targets = targets.select { |i| only.include?(i.integration_name) } if only
+        targets = targets.reject { |i| except.include?(i.integration_name) } if except
+
+        results = targets.each_with_object([]) do |integration, instrumented|
+          result = instrument!(integration.integration_name)
+          # Note: false means skipped (not applicable) or failed (error logged at lower level)
+          Braintrust::Log.debug("auto_instrument! :#{integration.integration_name} #{result ? "instrumented" : "skipped"}")
+          instrumented << integration.integration_name if result
+        end
+        Braintrust::Log.debug("auto_instrument! complete: #{results.inspect}")
+        results
+      end
+
+      # Instrument a registered integration by name.
+      #
+      # @param name [Symbol] The integration name (e.g., :openai, :anthropic)
+      # @param options [Hash] Optional configuration
+      # @option options [Object] :target Optional target instance to instrument specifically
+      # @option options [OpenTelemetry::SDK::Trace::TracerProvider] :tracer_provider Optional tracer provider
+      # @return [Boolean] true if instrumentation succeeded
+      #
+      # @example Instrument all OpenAI clients
+      #   Braintrust::Contrib.instrument!(:openai)
+      #
+      # @example Instrument specific OpenAI client instance
+      #   client = OpenAI::Client.new
+      #   Braintrust::Contrib.instrument!(:openai, target: client, tracer_provider: my_provider)
+      def instrument!(name, **options)
+        if (integration = registry[name])
+          integration.instrument!(**options)
+        else
+          Braintrust::Log.error("No integration for '#{name}' is defined!")
+          false
+        end
+      end
+
+      # Get the default tracer provider, falling back to OpenTelemetry global.
+      # @return [OpenTelemetry::Trace::TracerProvider]
+      def default_tracer_provider
+        @default_tracer_provider || ::OpenTelemetry.tracer_provider
+      end
+
+      # Get the context for a target object.
+      # @param target [Object] The object to retrieve context from
+      # @return [Context, nil] The context if found, nil otherwise
+      def context_for(target)
+        Context.from(target)
+      end
+
+      # Get the tracer provider for a target.
+      # Checks target's context first, then falls back to contrib default.
+      # @param target [Object] The object to look up tracer provider for
+      # @return [OpenTelemetry::Trace::TracerProvider]
+      def tracer_provider_for(target)
+        context_for(target)&.[](:tracer_provider) || default_tracer_provider
+      end
+
+      # Get a tracer for a target, using its context's tracer_provider if available.
+      # @param target [Object] The object to look up context from
+      # @param name [String] Tracer name
+      # @return [OpenTelemetry::Trace::Tracer]
+      def tracer_for(target, name: "braintrust")
+        tracer_provider_for(target).tracer(name)
+      end
+    end
+  end
+end
+
+# Load integration stubs (eager load minimal metadata).
+require_relative "contrib/openai/integration"
+require_relative "contrib/ruby_openai/integration"
+require_relative "contrib/ruby_llm/integration"
+require_relative "contrib/anthropic/integration"
+
+# Register integrations
+Braintrust::Contrib::OpenAI::Integration.register!
+Braintrust::Contrib::RubyOpenAI::Integration.register!
+Braintrust::Contrib::RubyLLM::Integration.register!
+Braintrust::Contrib::Anthropic::Integration.register!

data/lib/braintrust/internal/env.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Braintrust
+  module Internal
+    # Environment variable utilities.
+    module Env
+      ENV_AUTO_INSTRUMENT = "BRAINTRUST_AUTO_INSTRUMENT"
+      ENV_INSTRUMENT_EXCEPT = "BRAINTRUST_INSTRUMENT_EXCEPT"
+      ENV_INSTRUMENT_ONLY = "BRAINTRUST_INSTRUMENT_ONLY"
+
+      def self.auto_instrument
+        ENV[ENV_AUTO_INSTRUMENT] != "false"
+      end
+
+      def self.instrument_except
+        parse_list(ENV_INSTRUMENT_EXCEPT)
+      end
+
+      def self.instrument_only
+        parse_list(ENV_INSTRUMENT_ONLY)
+      end
+
+      # Parse a comma-separated environment variable into an array of symbols.
+      # @param key [String] The environment variable name
+      # @return [Array<Symbol>, nil] Array of symbols, or nil if not set
+      def self.parse_list(key)
+        value = ENV[key]
+        return nil unless value
+        value.split(",").map(&:strip).map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/braintrust/internal/time.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Braintrust
+  module Internal
+    # Time utilities using the monotonic clock for accurate duration measurements.
+    #
+    # Unlike Time.now, the monotonic clock is not affected by system clock adjustments
+    # (NTP updates, daylight saving, manual changes) and provides accurate elapsed time.
+    #
+    # @see https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way/
+    module Time
+      # Measure elapsed time using the monotonic clock.
+      #
+      # Three modes of operation:
+      #
+      # 1. With a block: executes the block and returns elapsed time in seconds
+      #    elapsed = Time.measure { some_operation }
+      #
+      # 2. Without arguments: returns the current monotonic time (for later comparison)
+      #    start = Time.measure
+      #    # ... later ...
+      #    elapsed = Time.measure(start)
+      #
+      # 3. With a start_time argument: returns elapsed time since start_time
+      #    start = Time.measure
+      #    elapsed = Time.measure(start)
+      #
+      # @param start_time [Float, nil] Optional start time from a previous measure call
+      # @yield Optional block to measure
+      # @return [Float] Elapsed time in seconds, or current monotonic time if no args/block
+      def self.measure(start_time = nil)
+        if block_given?
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          yield
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        elsif start_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+        else
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/braintrust/setup.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Setup file for automatic SDK initialization and instrumentation.
+# Load this file to automatically initialize Braintrust and instrument all available LLM libraries.
+#
+# Usage:
+#   # Gemfile
+#   gem "braintrust", require: "braintrust/setup"
+#
+#   # Or in code
+#   require "braintrust/setup"
+#
+# Environment variables:
+#   BRAINTRUST_API_KEY - Required for tracing to work
+#   BRAINTRUST_AUTO_INSTRUMENT - Set to "false" to disable (default: true)
+#   BRAINTRUST_INSTRUMENT_ONLY - Comma-separated whitelist
+#   BRAINTRUST_INSTRUMENT_EXCEPT - Comma-separated blacklist
+
+require_relative "../braintrust"
+require_relative "contrib/setup"
+
+module Braintrust
+  module Setup
+    class << self
+      def run!
+        return if @setup_complete
+
+        @setup_complete = true
+
+        Braintrust::Log.debug("Braintrust setting up...")
+
+        # Initialize Braintrust (silent failure if no API key)
+        # Must run in every process - tracer provider doesn't persist across Kernel.exec
+        begin
+          Braintrust.init
+        rescue => e
+          Braintrust::Log.error("Failed to automatically setup Braintrust: #{e.message}")
+        end
+
+        # Always setup contrib - hooks don't persist across Kernel.exec
+        Contrib::Setup.run!
+
+        Braintrust::Log.debug("Braintrust setup complete. Auto-instrumentation enabled: #{Braintrust::Internal::Env.auto_instrument}")
+      end
+    end
+  end
+end
+
+# Auto-setup when required
+Braintrust::Setup.run!

data/lib/braintrust/state.rb

@@ -93,6 +93,11 @@ module Braintrust
       if enable_tracing
         require_relative "trace"
         Trace.setup(self, tracer_provider, exporter: exporter)
+
+        # Propagate tracer_provider to Contrib if loaded (soft dependency check)
+        if defined?(Braintrust::Contrib)
+          Braintrust::Contrib.init(tracer_provider: tracer_provider)
+        end
       end
     end
 

data/lib/braintrust/trace.rb

@@ -6,57 +6,6 @@ require_relative "trace/span_processor"
 require_relative "trace/span_filter"
 require_relative "logger"
 
-# OpenAI integrations - both ruby-openai and openai gems use require "openai"
-# so we detect which one actually loaded the code and require the appropriate integration
-begin
-  require "openai"
-
-  # Check which OpenAI gem's code is actually loaded by inspecting $LOADED_FEATURES
-  # (both gems can be in Gem.loaded_specs, but only one's code can be loaded)
-  openai_load_path = $LOADED_FEATURES.find { |f| f.end_with?("/openai.rb") }
-
-  if openai_load_path&.include?("ruby-openai")
-    # alexrudall/ruby-openai gem (path contains "ruby-openai-X.Y.Z")
-    require_relative "trace/contrib/github.com/alexrudall/ruby-openai/ruby-openai"
-  elsif openai_load_path&.include?("/openai-")
-    # Official openai gem (path contains "openai-X.Y.Z")
-    require_relative "trace/contrib/openai"
-  elsif Gem.loaded_specs["ruby-openai"]
-    # Fallback: ruby-openai in loaded_specs (for unusual installation paths)
-    require_relative "trace/contrib/github.com/alexrudall/ruby-openai/ruby-openai"
-  elsif Gem.loaded_specs["openai"]
-    # Fallback: official openai in loaded_specs (for unusual installation paths)
-    require_relative "trace/contrib/openai"
-  end
-rescue LoadError
-  # No OpenAI gem installed - integration will not be available
-end
-
-# Anthropic integration is optional - automatically loaded if anthropic gem is available
-begin
-  require "anthropic"
-  require_relative "trace/contrib/anthropic"
-rescue LoadError
-  # Anthropic gem not installed - integration will not be available
-end
-
-# RubyLLM integration is optional - automatically loaded if ruby_llm gem is available
-#
-# Usage:
-#   # Wrap the class once (affects all instances):
-#   Braintrust::Trace::RubyLLM.wrap
-#
-#   # Or wrap a specific instance:
-#   chat = RubyLLM.chat(model: "gpt-4o-mini")
-#   Braintrust::Trace::RubyLLM.wrap(chat)
-#
-begin
-  require "ruby_llm"
-  require_relative "trace/contrib/github.com/crmne/ruby_llm"
-rescue LoadError
-  # RubyLLM gem not installed - integration will not be available
-end
-
 module Braintrust
   module Trace
     # Set up OpenTelemetry tracing with Braintrust

data/lib/braintrust/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Braintrust
-  VERSION = "0.0.12"
+  VERSION = "0.1.0"
 end