sentry-agents 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7fa4b4fcf3ca85a7404b987df6ee161819a05375a4ec0045ad02fc5e221ca394
+  data.tar.gz: 84a5ebb7522b169f6e0018df6095c8868fe4305c0e3d1ac91b706995bd63b9c1
+SHA512:
+  metadata.gz: c4ee05c5e3cac969d620e9379b25ed4b6b657dbfefb7b6263374974c60ef46ee032974a1f8ba2c34b5d86d765222e8df534e1d83c5126f5fd63d84b3cf27c36d
+  data.tar.gz: ffc74b1b22eee48374460672570cdb945ee54cb74acca1473126412a4627dc83daf636d23b2af5444dc722a0fa9d6fb09f1ddfa703a6ef785995e68bec6a2048

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-12-15
+
+### Added
+
+- Initial release
+- Core `Sentry::Agents::Instrumentation` module with span helpers:
+  - `with_agent_span` - Wrap agent invocations
+  - `with_chat_span` - Wrap LLM chat API calls
+  - `with_tool_span` - Wrap tool/function executions
+  - `with_handoff_span` - Track stage transitions
+- Configuration system with:
+  - Configurable default LLM system/provider
+  - Max string length for serialization
+  - Custom data filtering hooks
+  - Debug mode
+- `SpanBuilder` helper class for consistent span creation
+- `Serializer` utility for data serialization and truncation
+- Graceful degradation when Sentry is not available
+- Full backward compatibility with `SwiftTail::AiAgentInstrumentation`

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SwiftTail
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,208 @@
+# Sentry Agents
+
+Sentry Gen AI instrumentation for AI/LLM agents in Ruby applications.
+
+Provides [Sentry's AI Agents monitoring](https://docs.sentry.io/platforms/python/tracing/instrumentation/custom-instrumentation/ai-agents-module/) capabilities for Ruby, supporting multiple LLM providers (Anthropic, OpenAI, Cohere, Google Gemini, etc.).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sentry-agents'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install sentry-agents
+```
+
+## Requirements
+
+- Ruby >= 3.1.0
+- sentry-ruby >= 5.0.0
+
+## Configuration
+
+```ruby
+Sentry::Agents.configure do |config|
+  # Default LLM provider (default: "anthropic")
+  config.default_system = "anthropic"
+
+  # Maximum string length for serialized data (default: 1000)
+  config.max_string_length = 1000
+
+  # Enable debug logging (default: false)
+  config.debug = false
+
+  # Custom data filtering (optional)
+  config.data_filter = ->(data) do
+    # Remove sensitive keys in production
+    data.delete("gen_ai.request.messages") if ENV["SENTRY_SKIP_MESSAGES"]
+    data
+  end
+end
+```
+
+## Usage
+
+### Manual Instrumentation
+
+Include the `Sentry::Agents::Instrumentation` module in any class:
+
+```ruby
+class MyAgent
+  include Sentry::Agents::Instrumentation
+
+  def process_request(user_message)
+    with_agent_span(agent_name: "MyAgent", model: "claude-3-5-sonnet") do
+      # Get LLM response
+      response = with_chat_span(model: "claude-3-5-sonnet") do
+        client.messages.create(
+          model: "claude-3-5-sonnet-20241022",
+          messages: [{ role: "user", content: user_message }]
+        )
+      end
+
+      # Execute tool if needed
+      if response.stop_reason == "tool_use"
+        with_tool_span(
+          tool_name: "search",
+          tool_input: { query: response.tool_input["query"] }
+        ) do
+          search_service.search(response.tool_input["query"])
+        end
+      end
+
+      # Track stage transition
+      with_handoff_span(from_stage: "processing", to_stage: "complete") do
+        update_status!(:complete)
+      end
+
+      response
+    end
+  end
+end
+```
+
+### Custom Provider Override
+
+Override the default provider on a per-span basis:
+
+```ruby
+class OpenAIAgent
+  include Sentry::Agents::Instrumentation
+
+  def process(message)
+    with_chat_span(model: "gpt-4", system: "openai") do
+      openai_client.chat(model: "gpt-4", messages: [message])
+    end
+  end
+end
+```
+
+## Span Types
+
+### Agent Invocation (`gen_ai.invoke_agent`)
+
+Wraps the overall agent execution lifecycle.
+
+```ruby
+with_agent_span(agent_name: "Emily", model: "claude-3-5-sonnet") do
+  # Full agent conversation logic
+end
+```
+
+### Chat Completion (`gen_ai.chat`)
+
+Wraps individual LLM API calls. Automatically captures:
+- Token usage (input/output tokens)
+- Response text
+
+```ruby
+with_chat_span(model: "claude-3-5-sonnet", messages: conversation_history) do
+  llm_client.chat(messages)
+end
+```
+
+### Tool Execution (`gen_ai.execute_tool`)
+
+Wraps tool/function executions. Captures:
+- Tool name
+- Tool input
+- Tool output
+
+```ruby
+with_tool_span(tool_name: "weather_lookup", tool_input: { city: "NYC" }) do
+  weather_api.get_forecast("NYC")
+end
+```
+
+### Handoff (`gen_ai.handoff`)
+
+Tracks stage transitions or agent handoffs.
+
+```ruby
+with_handoff_span(from_stage: "greeting", to_stage: "qualification") do
+  update_conversation_stage!
+end
+```
+
+## Graceful Degradation
+
+All instrumentation methods gracefully degrade when Sentry is not available or tracing is disabled. Your code will continue to work normally without any errors.
+
+```ruby
+# Works fine even without Sentry initialized
+with_chat_span(model: "claude-3-5-sonnet") do
+  llm_client.chat(messages)  # Still executes, just without tracing
+end
+```
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+rake test      # Run tests
+rake rubocop   # Run linter
+rake           # Run both
+```
+
+## Releasing
+
+Releases are automated via GitHub Actions. To publish a new version:
+
+1. Update the version in `lib/sentry/agents/version.rb`
+2. Update `CHANGELOG.md` with the new version's changes
+3. Commit the changes:
+   ```bash
+   git add -A && git commit -m "Bump version to X.Y.Z"
+   ```
+4. Create and push a version tag:
+   ```bash
+   git tag vX.Y.Z
+   git push origin main --tags
+   ```
+
+The release workflow will automatically:
+- Run the test suite
+- Build the gem
+- Publish to RubyGems
+- Create a GitHub Release with auto-generated release notes
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sentry-agents/sentry-agents-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).

data/lib/sentry/agents/configuration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Agents
+    # Configuration class for sentry-agents gem
+    #
+    # @example Basic configuration
+    #   Sentry::Agents.configure do |config|
+    #     config.default_system = "anthropic"
+    #     config.max_string_length = 2000
+    #   end
+    #
+    class Configuration
+      # Default LLM provider system name (e.g., "anthropic", "openai", "cohere")
+      # @return [String]
+      attr_accessor :default_system
+
+      # Enable auto-instrumentation for RubyLLM gem
+      # @return [Boolean]
+      attr_accessor :auto_instrument_ruby_llm
+
+      # Enable auto-instrumentation for LangChain.rb gem
+      # @return [Boolean]
+      attr_accessor :auto_instrument_langchainrb
+
+      # Maximum length for serialized strings in span attributes
+      # @return [Integer]
+      attr_accessor :max_string_length
+
+      # Enable debug logging
+      # @return [Boolean]
+      attr_accessor :debug
+
+      # Custom data filter hook for sanitizing span data
+      # @return [Proc, nil]
+      attr_accessor :data_filter
+
+      def initialize
+        @default_system = "anthropic"
+        @auto_instrument_ruby_llm = false
+        @auto_instrument_langchainrb = false
+        @max_string_length = 1000
+        @debug = false
+        @data_filter = nil
+      end
+    end
+  end
+end

data/lib/sentry/agents/instrumentation.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Agents
+    # Core instrumentation module that provides span helper methods
+    #
+    # Include this module in any class that needs to create Sentry Gen AI spans.
+    # All methods are designed to gracefully degrade when Sentry is not available.
+    #
+    # @example Basic usage
+    #   class MyAgent
+    #     include Sentry::Agents::Instrumentation
+    #
+    #     def process(message)
+    #       with_agent_span(agent_name: "MyAgent", model: "claude-3-5-sonnet") do
+    #         with_chat_span(model: "claude-3-5-sonnet") do
+    #           llm_client.chat(message)
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    module Instrumentation
+      # Wrap an agent invocation (e.g., full conversation lifecycle)
+      #
+      # Creates a gen_ai.invoke_agent span that captures the overall agent execution.
+      # Token usage is automatically captured if the block result responds to
+      # :input_tokens and :output_tokens.
+      #
+      # @param agent_name [String] name of the agent (e.g., "Emily", "CustomerService")
+      # @param model [String] LLM model identifier (e.g., "claude-3-5-sonnet")
+      # @param system [String, nil] override default LLM provider system name
+      # @yield the agent logic
+      # @return [Object] the block result
+      #
+      # @example
+      #   with_agent_span(agent_name: "Emily", model: "claude-3-5-sonnet") do
+      #     process_conversation
+      #   end
+      #
+      def with_agent_span(agent_name:, model:, system: nil)
+        return yield unless sentry_tracing_available?
+
+        SpanBuilder.build(
+          operation: :invoke_agent,
+          description: "invoke_agent #{agent_name}",
+          attributes: {
+            "gen_ai.operation.name" => "invoke_agent",
+            "gen_ai.system" => system_name(system),
+            "gen_ai.request.model" => model,
+            "gen_ai.agent.name" => agent_name
+          }
+        ) do |span|
+          result = yield
+          capture_token_usage(span, result)
+          result
+        end
+      end
+
+      # Wrap an LLM chat API call
+      #
+      # Creates a gen_ai.chat span that captures a single LLM API call.
+      # Automatically captures token usage and response text if available.
+      #
+      # @param model [String] LLM model identifier
+      # @param messages [Array<Hash>, nil] optional message array for the request
+      # @param system [String, nil] override default LLM provider system name
+      # @yield the LLM call
+      # @return [Object] the block result (should respond to :input_tokens, :output_tokens, :content)
+      #
+      # @example
+      #   with_chat_span(model: "claude-3-5-sonnet", messages: conversation_history) do
+      #     llm_client.chat(messages)
+      #   end
+      #
+      def with_chat_span(model:, messages: nil, system: nil)
+        return yield unless sentry_tracing_available?
+
+        attributes = {
+          "gen_ai.operation.name" => "chat",
+          "gen_ai.system" => system_name(system),
+          "gen_ai.request.model" => model
+        }
+
+        attributes["gen_ai.request.messages"] = Serializer.serialize(messages) if messages
+
+        SpanBuilder.build(
+          operation: :chat,
+          description: "chat #{model}",
+          attributes: attributes
+        ) do |span|
+          result = yield
+          capture_token_usage(span, result)
+          capture_response_text(span, result)
+          result
+        end
+      end
+
+      # Wrap a tool/function execution
+      #
+      # Creates a gen_ai.execute_tool span that captures tool execution.
+      # The tool output is automatically captured from the block result.
+      #
+      # @param tool_name [String] name of the tool being executed
+      # @param tool_input [Hash, String, nil] tool input parameters
+      # @param system [String, nil] override default LLM provider system name
+      # @yield the tool execution
+      # @return [Object] the block result
+      #
+      # @example
+      #   with_tool_span(tool_name: "search", tool_input: { query: "flights" }) do
+      #     search_service.search("flights")
+      #   end
+      #
+      def with_tool_span(tool_name:, tool_input: nil, system: nil)
+        return yield unless sentry_tracing_available?
+
+        attributes = {
+          "gen_ai.operation.name" => "execute_tool",
+          "gen_ai.system" => system_name(system),
+          "gen_ai.tool.name" => tool_name
+        }
+
+        attributes["gen_ai.tool.input"] = Serializer.serialize(tool_input) if tool_input
+
+        SpanBuilder.build(
+          operation: :execute_tool,
+          description: "execute_tool #{tool_name}",
+          attributes: attributes
+        ) do |span|
+          result = yield
+          capture_tool_output(span, result)
+          result
+        end
+      end
+
+      # Track agent stage transitions or handoffs
+      #
+      # Creates a gen_ai.handoff span that captures transitions between
+      # stages or handoffs between agents.
+      #
+      # @param from_stage [String] source stage/agent
+      # @param to_stage [String] destination stage/agent
+      # @param system [String, nil] override default LLM provider system name
+      # @yield the transition logic
+      # @return [Object] the block result
+      #
+      # @example
+      #   with_handoff_span(from_stage: "greeting", to_stage: "qualification") do
+      #     update_conversation_stage!
+      #   end
+      #
+      def with_handoff_span(from_stage:, to_stage:, system: nil)
+        return yield unless sentry_tracing_available?
+
+        SpanBuilder.build(
+          operation: :handoff,
+          description: "handoff from #{from_stage} to #{to_stage}",
+          attributes: {
+            "gen_ai.operation.name" => "handoff",
+            "gen_ai.system" => system_name(system),
+            "gen_ai.handoff.from" => from_stage,
+            "gen_ai.handoff.to" => to_stage
+          }
+        ) do |_span|
+          yield
+        end
+      end
+
+      private
+
+      # Check if Sentry tracing is available
+      #
+      # @return [Boolean]
+      #
+      def sentry_tracing_available?
+        SpanBuilder.sentry_available?
+      end
+
+      # Get system name (provider) from config or override
+      #
+      # @param override [String, nil]
+      # @return [String]
+      #
+      def system_name(override = nil)
+        override || Sentry::Agents.configuration.default_system
+      end
+
+      # Capture token usage from result if available
+      # Optimized to minimize method calls in hot paths
+      #
+      # @param span [Sentry::Span, nil]
+      # @param result [Object]
+      # @return [void]
+      #
+      def capture_token_usage(span, result)
+        return unless span && result
+
+        # Cache values to avoid repeated method lookups
+        input_tokens = result.input_tokens if result.respond_to?(:input_tokens)
+        output_tokens = result.output_tokens if result.respond_to?(:output_tokens)
+
+        span.set_data("gen_ai.usage.input_tokens", input_tokens) if input_tokens
+        span.set_data("gen_ai.usage.output_tokens", output_tokens) if output_tokens
+      end
+
+      # Capture response text from result if available
+      #
+      # @param span [Sentry::Span, nil]
+      # @param result [Object]
+      # @return [void]
+      #
+      def capture_response_text(span, result)
+        return unless span && result
+        return unless result.respond_to?(:content) && result.content
+
+        # Sentry expects response.text as JSON array
+        span.set_data("gen_ai.response.text", [result.content].to_json)
+      end
+
+      # Capture tool output in span
+      #
+      # @param span [Sentry::Span, nil]
+      # @param result [Object]
+      # @return [void]
+      #
+      def capture_tool_output(span, result)
+        return unless span && result
+
+        span.set_data("gen_ai.tool.output", Serializer.serialize(result))
+      end
+    end
+  end
+end

data/lib/sentry/agents/serializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Sentry
+  module Agents
+    # Handles data serialization for span attributes
+    #
+    # Provides utilities for converting various data types to strings
+    # suitable for Sentry span attributes, with truncation and filtering.
+    #
+    class Serializer
+      class << self
+        # Serialize a value for use in span attributes
+        #
+        # @param value [Object] the value to serialize
+        # @param max_length [Integer, nil] maximum length for the result
+        # @return [String, nil] the serialized value
+        #
+        # @example
+        #   Serializer.serialize({ key: "value" })
+        #   # => '{"key":"value"}'
+        #
+        #   Serializer.serialize("a" * 2000, max_length: 100)
+        #   # => "aaa...aaa..." (truncated to 100 chars)
+        #
+        def serialize(value, max_length: nil)
+          max_length ||= Sentry::Agents.configuration.max_string_length
+
+          result = case value
+                   when String
+                     value
+                   when Hash, Array
+                     value.to_json
+                   when NilClass
+                     return nil
+                   else
+                     value.to_s
+                   end
+
+          truncate(result, max_length)
+        end
+
+        # Truncate a string to the specified maximum length
+        #
+        # @param str [String] the string to truncate
+        # @param max_length [Integer] maximum length
+        # @return [String] the truncated string
+        #
+        def truncate(str, max_length)
+          return str if str.nil? || str.length <= max_length
+
+          "#{str[0...max_length]}..."
+        end
+
+        # Apply custom data filter if configured
+        #
+        # @param data [Hash] the data to filter
+        # @return [Hash] the filtered data
+        #
+        def filter(data)
+          filter_proc = Sentry::Agents.configuration.data_filter
+          return data unless filter_proc
+
+          filter_proc.call(data.dup)
+        end
+      end
+    end
+  end
+end

data/lib/sentry/agents/span_builder.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Agents
+    # Helper class for building Sentry spans with Gen AI attributes
+    #
+    # Provides a consistent interface for creating spans across all
+    # instrumentation methods.
+    #
+    class SpanBuilder
+      # Mapping of operation types to Sentry span operation names
+      OPERATIONS = {
+        invoke_agent: "gen_ai.invoke_agent",
+        chat: "gen_ai.chat",
+        execute_tool: "gen_ai.execute_tool",
+        handoff: "gen_ai.handoff"
+      }.freeze
+
+      class << self
+        # Build and execute a Sentry span
+        #
+        # @param operation [Symbol] one of :invoke_agent, :chat, :execute_tool, :handoff
+        # @param description [String] span description
+        # @param attributes [Hash] initial span attributes
+        # @yield [Sentry::Span, nil] the created span (or nil if unavailable)
+        # @return [Object] the block result
+        #
+        # @example
+        #   SpanBuilder.build(
+        #     operation: :chat,
+        #     description: "chat claude-3-5-sonnet",
+        #     attributes: { "gen_ai.request.model" => "claude-3-5-sonnet" }
+        #   ) do |span|
+        #     # perform LLM call
+        #   end
+        #
+        def build(operation:, description:, attributes: {})
+          return yield(nil) unless sentry_available?
+
+          # Only rescue errors from Sentry span creation itself, not from user code
+          span = begin
+            create_span(operation, description)
+          rescue StandardError => e
+            log_span_error(e)
+            nil
+          end
+
+          # If span creation failed, execute without instrumentation
+          return yield(nil) unless span
+
+          # Execute user code within the span - let their exceptions propagate
+          begin
+            set_attributes(span, attributes)
+            yield(span)
+          ensure
+            # Always finish the span, even if user code raises
+            finish_span(span)
+          end
+        end
+
+        # Set attributes on a span
+        #
+        # @param span [Sentry::Span, nil] the span to modify
+        # @param attributes [Hash] attributes to set
+        # @return [void]
+        #
+        def set_attributes(span, attributes)
+          return unless span
+
+          filtered = Serializer.filter(attributes)
+          filtered.each do |key, value|
+            span.set_data(key, value) if value_present?(value)
+          end
+        end
+
+        # Check if Sentry tracing is available
+        #
+        # @return [Boolean] true if Sentry is initialized and has an active span
+        #
+        def sentry_available?
+          defined?(Sentry) &&
+            Sentry.initialized? &&
+            Sentry.get_current_scope&.get_span
+        end
+
+        private
+
+        def create_span(operation, description)
+          # Start a child span manually so we control when it finishes
+          parent_span = Sentry.get_current_scope&.get_span
+          return nil unless parent_span
+
+          parent_span.start_child(
+            op: OPERATIONS[operation],
+            description: description
+          )
+        end
+
+        def finish_span(span)
+          span&.finish
+        rescue StandardError => e
+          log_span_error(e)
+        end
+
+        def log_span_error(error)
+          return unless Sentry::Agents.configuration.debug
+
+          warn "[sentry-agents] Span error: #{error.class} - #{error.message}"
+        end
+
+        # Check if a value is present (not nil and not empty if applicable)
+        #
+        # @param value [Object] the value to check
+        # @return [Boolean]
+        #
+        def value_present?(value)
+          return false if value.nil?
+          return !value.empty? if value.respond_to?(:empty?)
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sentry/agents/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Agents
+    VERSION = "0.1.0"
+  end
+end

data/lib/sentry/agents.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "agents/version"
+require_relative "agents/configuration"
+require_relative "agents/serializer"
+require_relative "agents/span_builder"
+require_relative "agents/instrumentation"
+
+module Sentry
+  # Sentry Gen AI instrumentation for AI/LLM agents
+  #
+  # @example Basic usage
+  #   class MyAgent
+  #     include Sentry::Agents::Instrumentation
+  #
+  #     def process(message)
+  #       with_agent_span(agent_name: "MyAgent", model: "claude-3-5-sonnet") do
+  #         # agent logic
+  #       end
+  #     end
+  #   end
+  #
+  module Agents
+    class << self
+      # @return [Configuration] the current configuration
+      # Thread-safe lazy initialization
+      def configuration
+        @mutex ||= Mutex.new
+        @mutex.synchronize do
+          @configuration ||= Configuration.new
+        end
+      end
+
+      # Configure the gem
+      #
+      # @yield [Configuration] the configuration object
+      # @return [void]
+      #
+      # @example
+      #   Sentry::Agents.configure do |config|
+      #     config.default_system = "anthropic"
+      #     config.auto_instrument_ruby_llm = true
+      #   end
+      #
+      def configure
+        yield(configuration)
+        apply_auto_instrumentation
+      end
+
+      # Reset configuration to defaults (mainly for testing)
+      # Thread-safe reset
+      # @return [void]
+      def reset_configuration!
+        @mutex ||= Mutex.new
+        @mutex.synchronize do
+          @configuration = Configuration.new
+        end
+      end
+
+      private
+
+      def apply_auto_instrumentation
+        if configuration.auto_instrument_ruby_llm && defined?(RubyLLM)
+          require_relative "agents/integrations/ruby_llm"
+          Integrations::RubyLLM.install
+        end
+
+        return unless configuration.auto_instrument_langchainrb && defined?(Langchain)
+
+        require_relative "agents/integrations/langchainrb"
+        Integrations::LangChainRb.install
+      end
+    end
+  end
+end

data/lib/sentry-agents.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "sentry/agents"

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: sentry-agents
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SwiftTail
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sentry-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+description: |
+  Provides Sentry Gen AI instrumentation for AI/LLM agents,
+  supporting multiple providers (Anthropic, OpenAI, etc.)
+  with auto-instrumentation for RubyLLM and LangChain.rb.
+email:
+- dev@flyswifttail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/sentry-agents.rb
+- lib/sentry/agents.rb
+- lib/sentry/agents/configuration.rb
+- lib/sentry/agents/instrumentation.rb
+- lib/sentry/agents/serializer.rb
+- lib/sentry/agents/span_builder.rb
+- lib/sentry/agents/version.rb
+homepage: https://github.com/sentry-agents/sentry-agents-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sentry-agents/sentry-agents-ruby
+  source_code_uri: https://github.com/sentry-agents/sentry-agents-ruby
+  changelog_uri: https://github.com/sentry-agents/sentry-agents-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Sentry Gen AI instrumentation for AI/LLM agents in Ruby
+test_files: []