braintrust 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39d85e02bd85a931ee7f16de103d48d1184048e3ad8d791eda37bc323a653716
-  data.tar.gz: a0b1d5493e8ad3004007e78d608154077a33c92a436bce23eb36cfbe94c3bdd4
+  metadata.gz: 6321acf7b780922ed97ea3cc57dde47a52947a10650a082dcfd9af780056d99a
+  data.tar.gz: 67c181e53537829931de704c7503cc056646652f9c1a61d914bc1ee0b7af69a2
 SHA512:
-  metadata.gz: a5dcbd1b2bf2c0ab2355ff36c9cfce4fe10e175c0aa8df80ea3176be4002271744ca3a9fd7ef52cec888e0b326772518554921f7d657a79ba347b26c4c93b80c
-  data.tar.gz: 78677bd57e6ed1778f74b87e050dd5bbfdc8390e73f919aa57ea680cd2cd4338086e5df4982274c3fd62e690d34ec81078d7c76e75a467ab2f5b0667e6d530d6
+  metadata.gz: bb8546fdbf0a448016a1d31ceb8729a40be59e0d8d081ef275f763a11dbb2f5df0134ec52fc3b1c15c41d9dcdf42fbbe6becaf00ab7ac882c8f2f7e173a9a61f
+  data.tar.gz: 41e6d13504302a3b3ec26697cb50ce4736040d910c8e293d37088311922daa77274fc4214c86543ca21209bf56e82b2f6f00d5fbc2d7d0d0baad6f1e77cc48ff

data/lib/braintrust/trace/contrib/anthropic.rb

@@ -196,7 +196,6 @@ module Braintrust
         wrapper = Module.new do
           define_method(:stream) do |**params, &block|
             tracer = tracer_provider.tracer("braintrust")
-            aggregated_events = []
 
             metadata = {
               "provider" => "anthropic",
@@ -256,183 +255,110 @@ module Braintrust
             end
 
             # Store references on the stream object itself for the wrapper
-            stream.instance_variable_set(:@braintrust_aggregated_events, aggregated_events)
             stream.instance_variable_set(:@braintrust_span, span)
             stream.instance_variable_set(:@braintrust_metadata, metadata)
+            stream.instance_variable_set(:@braintrust_span_finished, false)
 
-            # Wrap the stream to aggregate events
-            original_each = stream.method(:each)
-            stream.define_singleton_method(:each) do |&user_block|
-              events = instance_variable_get(:@braintrust_aggregated_events)
-              span_obj = instance_variable_get(:@braintrust_span)
-              meta = instance_variable_get(:@braintrust_metadata)
-
-              begin
-                original_each.call do |event|
-                  # Store event data for aggregation
-                  events << event.to_h if event.respond_to?(:to_h)
-                  # Call user's block if provided
-                  user_block&.call(event)
-                end
-              rescue => e
-                span_obj.record_exception(e)
-                span_obj.status = ::OpenTelemetry::Trace::Status.error("Streaming error: #{e.message}")
-                raise
-              ensure
-                # Always aggregate and finish span after stream completes
-                unless events.empty?
-                  aggregated_output = Braintrust::Trace::Anthropic.aggregate_streaming_events(events)
-
-                  # Set output
-                  if aggregated_output[:content]
-                    output = [{
-                      role: "assistant",
-                      content: aggregated_output[:content]
-                    }]
-                    Braintrust::Trace::Anthropic.set_json_attr(span_obj, "braintrust.output_json", output)
-                  end
-
-                  # Set metrics if usage is available
-                  if aggregated_output[:usage]
-                    metrics = Braintrust::Trace::Anthropic.parse_usage_tokens(aggregated_output[:usage])
-                    Braintrust::Trace::Anthropic.set_json_attr(span_obj, "braintrust.metrics", metrics) unless metrics.empty?
-                  end
-
-                  # Update metadata with response fields
-                  meta["stop_reason"] = aggregated_output[:stop_reason] if aggregated_output[:stop_reason]
-                  meta["model"] = aggregated_output[:model] if aggregated_output[:model]
-                  Braintrust::Trace::Anthropic.set_json_attr(span_obj, "braintrust.metadata", meta)
-                end
+            # Local helper for brevity
+            set_json_attr = ->(attr_name, obj) { Braintrust::Trace::Anthropic.set_json_attr(span, attr_name, obj) }
 
-                span_obj.finish
+            # Helper lambda to extract stream data and set span attributes
+            # This is DRY - used by both .each() and .text() wrappers
+            extract_stream_metadata = lambda do
+              # Extract the SDK's internal accumulated message (built during streaming)
+              acc_msg = stream.instance_variable_get(:@accumated_message_snapshot)
+              return unless acc_msg
+
+              # Set output from accumulated message
+              if acc_msg.respond_to?(:content) && acc_msg.content
+                content_array = acc_msg.content.map(&:to_h)
+                output = [{
+                  role: acc_msg.respond_to?(:role) ? acc_msg.role : "assistant",
+                  content: content_array
+                }]
+                set_json_attr.call("braintrust.output_json", output)
               end
-            end
 
-            # If a block was provided to stream(), call each with it immediately
-            if block
-              stream.each(&block)
+              # Set metrics from accumulated message
+              if acc_msg.respond_to?(:usage) && acc_msg.usage
+                metrics = Braintrust::Trace::Anthropic.parse_usage_tokens(acc_msg.usage)
+                set_json_attr.call("braintrust.metrics", metrics) unless metrics.empty?
+              end
+
+              # Update metadata with response fields
+              if acc_msg.respond_to?(:stop_reason) && acc_msg.stop_reason
+                metadata["stop_reason"] = acc_msg.stop_reason
+              end
+              if acc_msg.respond_to?(:model) && acc_msg.model
+                metadata["model"] = acc_msg.model
+              end
+              set_json_attr.call("braintrust.metadata", metadata)
             end
 
-            stream
-          end
-        end
+            # Helper lambda to finish span (prevents double-finishing via closure)
+            finish_braintrust_span = lambda do
+              return if stream.instance_variable_get(:@braintrust_span_finished)
+              stream.instance_variable_set(:@braintrust_span_finished, true)
 
-        # Prepend the wrapper to the messages resource
-        client.messages.singleton_class.prepend(wrapper)
-      end
+              extract_stream_metadata.call
+              span.finish
+            end
 
-      # Aggregate streaming events into a single response structure
-      # @param events [Array<Hash>] array of event hashes from stream
-      # @return [Hash] aggregated response with content, usage, etc.
-      def self.aggregate_streaming_events(events)
-        return {} if events.empty?
-
-        result = {
-          content: [],
-          usage: {},
-          stop_reason: nil,
-          model: nil
-        }
-
-        # Track content blocks by index
-        content_blocks = {}
-        content_builders = {}
-
-        events.each do |event|
-          event_type = event[:type] || event["type"]
-          next unless event_type
-
-          case event_type
-          when "message_start"
-            # Extract model and initial usage (input tokens, cache tokens)
-            message = event[:message] || event["message"]
-            if message
-              result[:model] = message[:model] || message["model"]
-              if message[:usage] || message["usage"]
-                usage = message[:usage] || message["usage"]
-                result[:usage].merge!(usage)
-              end
+            # Wrap .each() to ensure span finishes after consumption
+            original_each = stream.method(:each)
+            stream.define_singleton_method(:each) do |&user_block|
+              # Consume stream, calling user's block for each event
+              # The SDK builds @accumated_message_snapshot internally
+              original_each.call(&user_block)
+            rescue => e
+              span.record_exception(e)
+              span.status = ::OpenTelemetry::Trace::Status.error("Streaming error: #{e.message}")
+              raise
+            ensure
+              # Extract accumulated message and finish span
+              finish_braintrust_span.call
             end
 
-          when "content_block_start"
-            # Initialize a new content block
-            index = event[:index] || event["index"]
-            content_block = event[:content_block] || event["content_block"]
-            content_blocks[index] = content_block if index && content_block
-
-          when "content_block_delta"
-            # Accumulate deltas for content blocks
-            index = event[:index] || event["index"]
-            delta = event[:delta] || event["delta"]
-            next unless index && delta
-
-            delta_type = delta[:type] || delta["type"]
-            content_blocks[index] ||= {}
-
-            case delta_type
-            when "text_delta"
-              # Accumulate text
-              text = delta[:text] || delta["text"]
-              if text
-                content_builders[index] ||= ""
-                content_builders[index] += text
-                content_blocks[index][:type] = "text"
-                content_blocks[index]["type"] = "text"
-              end
+            # Wrap .text() to return an Enumerable that ensures span finishes
+            original_text = stream.method(:text)
+            stream.define_singleton_method(:text) do
+              text_enum = original_text.call
 
-            when "input_json_delta"
-              # Accumulate JSON for tool_use blocks
-              partial_json = delta[:partial_json] || delta["partial_json"]
-              if partial_json
-                content_builders[index] ||= ""
-                content_builders[index] += partial_json
-                content_blocks[index][:type] = "tool_use"
-                content_blocks[index]["type"] = "tool_use"
+              # Return wrapper Enumerable that finishes span after consumption
+              Enumerator.new do |y|
+                # Consume text enumerable (this consumes underlying stream)
+                # The SDK builds @accumated_message_snapshot internally
+                text_enum.each { |text| y << text }
+              rescue => e
+                span.record_exception(e)
+                span.status = ::OpenTelemetry::Trace::Status.error("Streaming error: #{e.message}")
+                raise
+              ensure
+                # Extract accumulated message and finish span
+                finish_braintrust_span.call
               end
             end
 
-          when "message_delta"
-            # Get final stop reason and cumulative usage (output tokens)
-            delta = event[:delta] || event["delta"]
-            if delta
-              stop_reason = delta[:stop_reason] || delta["stop_reason"]
-              result[:stop_reason] = stop_reason if stop_reason
+            # Wrap .close() to ensure span finishes even if stream not consumed
+            original_close = stream.method(:close)
+            stream.define_singleton_method(:close) do
+              original_close.call
+            ensure
+              # Finish span even if stream was closed early
+              finish_braintrust_span.call
             end
 
-            usage = event[:usage] || event["usage"]
-            result[:usage].merge!(usage) if usage
-          end
-        end
-
-        # Build final content array from aggregated blocks
-        content_builders.each do |index, text|
-          block = content_blocks[index]
-          next unless block
-
-          block_type = block[:type] || block["type"]
-          case block_type
-          when "text"
-            block[:text] = text
-            block["text"] = text
-          when "tool_use"
-            # Parse the accumulated JSON string
-            begin
-              parsed = JSON.parse(text)
-              block[:input] = parsed
-              block["input"] = parsed
-            rescue JSON::ParserError
-              block[:input] = text
-              block["input"] = text
+            # If a block was provided to stream(), call each with it immediately
+            if block
+              stream.each(&block)
             end
-          end
-        end
 
-        # Convert blocks hash to sorted array
-        if content_blocks.any?
-          result[:content] = content_blocks.keys.sort.map { |idx| content_blocks[idx] }
+            stream
+          end
         end
 
-        result
+        # Prepend the wrapper to the messages resource
+        client.messages.singleton_class.prepend(wrapper)
       end
     end
   end

data/lib/braintrust/trace/contrib/github.com/alexrudall/ruby-openai/ruby-openai.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "opentelemetry/sdk"
+require "json"
+
+module Braintrust
+  module Trace
+    module AlexRudall
+      module RubyOpenAI
+        # 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
+
+        # Parse usage tokens from OpenAI API response, handling nested token_details
+        # Maps OpenAI field names to Braintrust standard names:
+        # - prompt_tokens → prompt_tokens
+        # - completion_tokens → completion_tokens
+        # - total_tokens → tokens
+        #
+        # @param usage [Hash] usage hash from OpenAI response
+        # @return [Hash<String, Integer>] metrics hash with normalized names
+        def self.parse_usage_tokens(usage)
+          metrics = {}
+          return metrics unless usage
+
+          # Basic token counts
+          metrics["prompt_tokens"] = usage["prompt_tokens"].to_i if usage["prompt_tokens"]
+          metrics["completion_tokens"] = usage["completion_tokens"].to_i if usage["completion_tokens"]
+          metrics["total_tokens"] = usage["total_tokens"].to_i if usage["total_tokens"]
+
+          # Rename total_tokens to tokens for consistency
+          metrics["tokens"] = metrics.delete("total_tokens") if metrics["total_tokens"]
+
+          metrics
+        end
+
+        # Wrap an OpenAI::Client (ruby-openai gem) to automatically create spans
+        # Supports both synchronous and streaming requests
+        # @param client [OpenAI::Client] the OpenAI client to wrap
+        # @param tracer_provider [OpenTelemetry::SDK::Trace::TracerProvider] the tracer provider (defaults to global)
+        def self.wrap(client, tracer_provider: nil)
+          tracer_provider ||= ::OpenTelemetry.tracer_provider
+
+          # Wrap chat completions
+          wrap_chat(client, tracer_provider)
+
+          client
+        end
+
+        # Wrap chat API
+        # @param client [OpenAI::Client] the OpenAI client
+        # @param tracer_provider [OpenTelemetry::SDK::Trace::TracerProvider] the tracer provider
+        def self.wrap_chat(client, tracer_provider)
+          # Create a wrapper module that intercepts the chat method
+          wrapper = Module.new do
+            define_method(:chat) do |parameters:|
+              tracer = tracer_provider.tracer("braintrust")
+
+              tracer.in_span("openai.chat.completions.create") do |span|
+                # Initialize metadata hash
+                metadata = {
+                  "provider" => "openai",
+                  "endpoint" => "/v1/chat/completions"
+                }
+
+                # Capture request metadata fields
+                metadata_fields = %w[
+                  model frequency_penalty logit_bias logprobs max_tokens n
+                  presence_penalty response_format seed service_tier stop
+                  stream stream_options temperature top_p top_logprobs
+                  tools tool_choice parallel_tool_calls user functions function_call
+                ]
+
+                metadata_fields.each do |field|
+                  field_sym = field.to_sym
+                  if parameters.key?(field_sym)
+                    # Special handling for stream parameter (it's a Proc)
+                    metadata[field] = if field == "stream"
+                      true  # Just mark as streaming
+                    else
+                      parameters[field_sym]
+                    end
+                  end
+                end
+
+                # Set input messages as JSON
+                if parameters[:messages]
+                  span.set_attribute("braintrust.input_json", JSON.generate(parameters[:messages]))
+                end
+
+                begin
+                  # Call the original method
+                  response = super(parameters: parameters)
+
+                  # Set output (choices) as JSON
+                  if response && response["choices"]&.any?
+                    span.set_attribute("braintrust.output_json", JSON.generate(response["choices"]))
+                  end
+
+                  # Set metrics (token usage)
+                  if response && response["usage"]
+                    metrics = Braintrust::Trace::AlexRudall::RubyOpenAI.parse_usage_tokens(response["usage"])
+                    span.set_attribute("braintrust.metrics", JSON.generate(metrics)) unless metrics.empty?
+                  end
+
+                  # Add response metadata fields
+                  if response
+                    metadata["id"] = response["id"] if response["id"]
+                    metadata["created"] = response["created"] if response["created"]
+                    metadata["system_fingerprint"] = response["system_fingerprint"] if response["system_fingerprint"]
+                    metadata["service_tier"] = response["service_tier"] if response["service_tier"]
+                  end
+
+                  # Set metadata ONCE at the end with complete hash
+                  span.set_attribute("braintrust.metadata", JSON.generate(metadata))
+
+                  response
+                rescue => e
+                  # Record exception in span
+                  span.record_exception(e)
+                  span.status = OpenTelemetry::Trace::Status.error("Exception: #{e.class} - #{e.message}")
+                  raise
+                end
+              end
+            end
+          end
+
+          # Prepend the wrapper to the client's singleton class
+          client.singleton_class.prepend(wrapper)
+        end
+      end
+    end
+  end
+end

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

@@ -124,7 +124,7 @@ module Braintrust
             choice_data[index] ||= {
               index: index,
               role: nil,
-              content: "",
+              content: +"",
               tool_calls: [],
               finish_reason: nil
             }
@@ -136,7 +136,7 @@ module Braintrust
 
             # Aggregate content
             if delta[:content]
-              choice_data[index][:content] += delta[:content]
+              choice_data[index][:content] << delta[:content]
             end
 
             # Aggregate tool_calls (similar to Go SDK logic)
@@ -149,15 +149,15 @@ module Braintrust
                     id: tool_call_delta[:id],
                     type: tool_call_delta[:type],
                     function: {
-                      name: tool_call_delta.dig(:function, :name) || "",
-                      arguments: tool_call_delta.dig(:function, :arguments) || ""
+                      name: tool_call_delta.dig(:function, :name) || +"",
+                      arguments: tool_call_delta.dig(:function, :arguments) || +""
                     }
                   }
                 elsif choice_data[index][:tool_calls].any?
                   # Continuation - append arguments to last tool call
                   last_tool_call = choice_data[index][:tool_calls].last
                   if tool_call_delta.dig(:function, :arguments)
-                    last_tool_call[:function][:arguments] += tool_call_delta[:function][:arguments]
+                    last_tool_call[:function][:arguments] << tool_call_delta[:function][:arguments]
                   end
                 end
               end
@@ -353,6 +353,119 @@ module Braintrust
 
             stream
           end
+
+          # Wrap stream for streaming chat completions (returns ChatCompletionStream with convenience methods)
+          define_method(:stream) do |**params|
+            tracer = tracer_provider.tracer("braintrust")
+            metadata = {
+              "provider" => "openai",
+              "endpoint" => "/v1/chat/completions"
+            }
+
+            # Start span with proper context (will be child of current span if any)
+            span = tracer.start_span("openai.chat.completions.create")
+
+            # Capture request metadata fields
+            metadata_fields = %i[
+              model frequency_penalty logit_bias logprobs max_tokens n
+              presence_penalty response_format seed service_tier stop
+              stream stream_options temperature top_p top_logprobs
+              tools tool_choice parallel_tool_calls user functions function_call
+            ]
+
+            metadata_fields.each do |field|
+              metadata[field.to_s] = params[field] if params.key?(field)
+            end
+            metadata["stream"] = true  # Explicitly mark as streaming
+
+            # Set input messages as JSON
+            if params[:messages]
+              messages_array = params[:messages].map(&:to_h)
+              span.set_attribute("braintrust.input_json", JSON.generate(messages_array))
+            end
+
+            # Set initial metadata
+            span.set_attribute("braintrust.metadata", JSON.generate(metadata))
+
+            # Call the original stream method with error handling
+            begin
+              stream = super(**params)
+            rescue => e
+              # Record exception if stream creation fails
+              span.record_exception(e)
+              span.status = ::OpenTelemetry::Trace::Status.error("OpenAI API error: #{e.message}")
+              span.finish
+              raise
+            end
+
+            # Local helper for setting JSON attributes
+            set_json_attr = ->(attr_name, obj) { Braintrust::Trace::OpenAI.set_json_attr(span, attr_name, obj) }
+
+            # Helper to extract metadata from SDK's internal snapshot
+            extract_stream_metadata = lambda do
+              # Access the SDK's internal accumulated completion snapshot
+              snapshot = stream.current_completion_snapshot
+              return unless snapshot
+
+              # Set output from accumulated choices
+              if snapshot.choices&.any?
+                choices_array = snapshot.choices.map(&:to_h)
+                set_json_attr.call("braintrust.output_json", choices_array)
+              end
+
+              # Set metrics if usage is available
+              if snapshot.usage
+                metrics = Braintrust::Trace::OpenAI.parse_usage_tokens(snapshot.usage)
+                set_json_attr.call("braintrust.metrics", metrics) unless metrics.empty?
+              end
+
+              # Update metadata with response fields
+              metadata["id"] = snapshot.id if snapshot.respond_to?(:id) && snapshot.id
+              metadata["created"] = snapshot.created if snapshot.respond_to?(:created) && snapshot.created
+              metadata["model"] = snapshot.model if snapshot.respond_to?(:model) && snapshot.model
+              metadata["system_fingerprint"] = snapshot.system_fingerprint if snapshot.respond_to?(:system_fingerprint) && snapshot.system_fingerprint
+              set_json_attr.call("braintrust.metadata", metadata)
+            end
+
+            # Prevent double-finish of span
+            finish_braintrust_span = lambda do
+              return if stream.instance_variable_get(:@braintrust_span_finished)
+              stream.instance_variable_set(:@braintrust_span_finished, true)
+              extract_stream_metadata.call
+              span.finish
+            end
+
+            # Wrap .each() method - this is the core consumption method
+            original_each = stream.method(:each)
+            stream.define_singleton_method(:each) do |&block|
+              original_each.call(&block)
+            rescue => e
+              span.record_exception(e)
+              span.status = ::OpenTelemetry::Trace::Status.error("Streaming error: #{e.message}")
+              raise
+            ensure
+              finish_braintrust_span.call
+            end
+
+            # Wrap .text() method - returns enumerable for text deltas
+            original_text = stream.method(:text)
+            stream.define_singleton_method(:text) do
+              text_enum = original_text.call
+              # Wrap the returned enumerable's .each method
+              text_enum.define_singleton_method(:each) do |&block|
+                super(&block)
+              rescue => e
+                span.record_exception(e)
+                span.status = ::OpenTelemetry::Trace::Status.error("Streaming error: #{e.message}")
+                raise
+              ensure
+                finish_braintrust_span.call
+              end
+              text_enum
+            end
+
+            stream
+          end
         end
 
         # Prepend the wrapper to the completions resource

data/lib/braintrust/trace.rb

@@ -6,12 +6,30 @@ require_relative "trace/span_processor"
 require_relative "trace/span_filter"
 require_relative "logger"
 
-# OpenAI integration is optional - automatically loaded if openai gem is available
+# 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"
-  require_relative "trace/contrib/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
-  # OpenAI gem not installed - integration will not be available
+  # No OpenAI gem installed - integration will not be available
 end
 
 # Anthropic integration is optional - automatically loaded if anthropic gem is available

data/lib/braintrust/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: braintrust
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Braintrust
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-exporter-otlp
   requirement: !ruby/object:Gem::Requirement
@@ -204,6 +204,7 @@ files:
 - lib/braintrust/trace.rb
 - lib/braintrust/trace/attachment.rb
 - lib/braintrust/trace/contrib/anthropic.rb
+- lib/braintrust/trace/contrib/github.com/alexrudall/ruby-openai/ruby-openai.rb
 - lib/braintrust/trace/contrib/openai.rb
 - lib/braintrust/trace/span_filter.rb
 - lib/braintrust/trace/span_processor.rb