langsmith-sdk 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd9018b27dbb87f1518a96570bedf1bf7b09702b18816f072f9764075cb6adf8
-  data.tar.gz: d69c6d0194c193fbb8567beb42d98042fa2e36fe24e855a0429753d7440efc63
+  metadata.gz: 5dbe9ea720616e2913af73fd43f00815f5ba0f4abc1003a28362800d25df651f
+  data.tar.gz: b9f37149e9d81794dced53aa493e76507ebb223470bc88c4036bb5a06ac20ecc
 SHA512:
-  metadata.gz: 156b32b2b1c09ef127183b8899dda9ba58bd837895b0baeb36074bc507b1ebed4a959847a9ca71b7dfaac93bcd8d0f35afe7a5aa9677ff8e9959c0a1132d4e56
-  data.tar.gz: '08a7208efb8a94a5d8a798fa4a3d490575342ca807629a0ba43e577ad7fb9c0f15c0c0476cc65067c1540f127332f9a79ebe07b2047a3c922f721f6bb56f1f17'
+  metadata.gz: b3d6e11333b5324f986d5fbe5a75caeb44ae5a8008a330eec1af39d1f8800268a00129861373f8fa514a14a5cb4d7d486a2d49cb82e4484df7b25bdadf513538
+  data.tar.gz: fdc400de8ebc5fb807f2b64762fdb496bc290294b2592a4a41289847de254ad81c29b039ced662f1141f991c55157c6261ef9b3589f5d61c795ee3d0a3631fc5

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2025-12-21
+
+### Added
+
+- `max_pending_entries` configuration option to limit buffer size and prevent unbounded memory growth
+- Configurable via `LANGSMITH_MAX_PENDING_ENTRIES` environment variable
+
+### Changed
+
+- Improved BatchProcessor thread safety with dedicated mutexes for pending arrays and flush operations
+- Better error logging in BatchProcessor with stack traces for debugging
+- Run data is now serialized on the calling thread to ensure correct state capture
+
+### Removed
+
+- **BREAKING**: Removed `Langsmith::Traceable` module - use `Langsmith.trace` block-based API instead
+
 ## [0.1.1] - 2025-12-21
 
 ### Added
@@ -20,7 +37,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release of the LangSmith Ruby SDK
 - Block-based tracing with `Langsmith.trace`
-- Method decoration with `Langsmith::Traceable` module
 - Automatic parent-child trace linking for nested traces
 - Thread-safe batch processing with background worker
 - Thread-local context for proper isolation in concurrent environments
@@ -42,7 +58,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `prompt` - Prompt template rendering
 - `parser` - Output parsing operations
 
-[Unreleased]: https://github.com/felipekb/langsmith-ruby-sdk/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/felipekb/langsmith-ruby-sdk/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/felipekb/langsmith-ruby-sdk/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/felipekb/langsmith-ruby-sdk/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/felipekb/langsmith-ruby-sdk/releases/tag/v0.1.0
 

data/README.md

@@ -79,26 +79,6 @@ Langsmith.trace("parent_chain", run_type: "chain") do
 end
 ```
 
-### Method Decoration with Traceable
-
-```ruby
-class MyService
-  include Langsmith::Traceable
-
-  traceable run_type: "chain"
-  def process(input)
-    # This method is automatically traced
-    transform(input)
-  end
-
-  traceable run_type: "llm", name: "openai_call"
-  def call_llm(prompt)
-    # Traced with custom name
-    client.chat(prompt)
-  end
-end
-```
-
 ## Run Types
 
 Supported run types:
@@ -157,24 +137,6 @@ Langsmith.trace("operation", tenant_id: "tenant-456") do
 end
 ```
 
-### With Traceable Module
-
-```ruby
-class MultiTenantService
-  include Langsmith::Traceable
-
-  traceable run_type: "chain", tenant_id: "tenant-123"
-  def process_for_tenant_123(data)
-    # Always traced to tenant-123
-  end
-
-  traceable run_type: "chain", tenant_id: "tenant-456"
-  def process_for_tenant_456(data)
-    # Always traced to tenant-456
-  end
-end
-```
-
 The SDK automatically batches traces by tenant ID, so traces for different tenants are sent in separate API requests with the appropriate `X-Tenant-Id` header.
 
 ## Token Usage Tracking
@@ -216,7 +178,7 @@ See [`examples/LLM_TRACING.md`](examples/LLM_TRACING.md) for comprehensive examp
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rspec` to run the tests.
 
 ## License
 

data/examples/LLM_TRACING.md

@@ -8,7 +8,6 @@ This guide shows how to trace LLM calls with the LangSmith Ruby SDK, including t
 - [Adding Metadata](#adding-metadata)
 - [Streaming LLM Calls](#streaming-llm-calls)
 - [Multi-Step Chains](#multi-step-chains)
-- [Using the Traceable Module](#using-the-traceable-module)
 - [OpenAI Integration](#openai-integration)
 - [Anthropic Integration](#anthropic-integration)
 - [Error Handling](#error-handling)
@@ -176,63 +175,6 @@ end
 
 ---
 
-## Using the Traceable Module
-
-Decorate methods for automatic tracing:
-
-```ruby
-class LLMService
-  include Langsmith::Traceable
-
-  def initialize(model: "gpt-4")
-    @model = model
-    @client = OpenAI::Client.new
-  end
-
-  traceable run_type: "llm", name: "llm_service.chat"
-  def chat(messages, temperature: 0.7)
-    response = @client.chat(
-      parameters: {
-        model: @model,
-        messages: messages,
-        temperature: temperature
-      }
-    )
-
-    # Access current run to set token usage
-    if (run = Langsmith.current_run)
-      run.set_token_usage(
-        prompt_tokens: response["usage"]["prompt_tokens"],
-        completion_tokens: response["usage"]["completion_tokens"]
-      )
-      run.add_metadata(model: @model, temperature: temperature)
-    end
-
-    response.dig("choices", 0, "message", "content")
-  end
-
-  traceable run_type: "llm", name: "llm_service.embed"
-  def embed(text)
-    response = @client.embeddings(
-      parameters: { model: "text-embedding-3-small", input: text }
-    )
-
-    Langsmith.current_run&.set_token_usage(
-      prompt_tokens: response["usage"]["prompt_tokens"],
-      completion_tokens: 0
-    )
-
-    response.dig("data", 0, "embedding")
-  end
-end
-
-# Usage
-service = LLMService.new(model: "gpt-4")
-response = service.chat([{ role: "user", content: "Hello!" }])
-```
-
----
-
 ## OpenAI Integration
 
 Complete wrapper for the ruby-openai gem:

data/examples/complex_agent.rb

@@ -152,27 +152,21 @@ end
 # =============================================================================
 
 class ResearchAgent
-  include Langsmith::Traceable
-
   def initialize
     @conversation_history = []
   end
 
-  traceable run_type: "chain", name: "research_agent.run"
   def run(user_query)
-    @conversation_history << { role: "user", content: user_query }
-
-    # Step 1: Analyze the query and plan
-    plan = plan_execution(user_query)
+    Langsmith.trace("research_agent.run", run_type: "chain", inputs: { query: user_query }) do
+      @conversation_history << { role: "user", content: user_query }
 
-    # Step 2: Execute the plan
-    results = execute_plan(plan)
+      plan = plan_execution(user_query)
+      results = execute_plan(plan)
+      response = synthesize_response(user_query, results)
 
-    # Step 3: Synthesize final response
-    response = synthesize_response(user_query, results)
-
-    @conversation_history << { role: "assistant", content: response }
-    response
+      @conversation_history << { role: "assistant", content: response }
+      response
+    end
   end
 
   private

data/examples/llm_tracing.rb

@@ -148,22 +148,17 @@ def trace_llm_chain(user_question)
   end
 end
 
-# Example 4: Using Traceable module for LLM service class
+# Example 4: Class-based tracing
 class LLMService
-  include Langsmith::Traceable
-
   def initialize(model: "gpt-4", temperature: 0.7)
     @model = model
     @temperature = temperature
   end
 
-  traceable run_type: "llm", name: "llm_service.chat"
   def chat(messages)
-    # In real code: response = @client.chat.completions.create(...)
-    response = simulate_openai_response(messages, @model)
+    Langsmith.trace("llm_service.chat", run_type: "llm", inputs: { messages: messages.length }) do |run|
+      response = simulate_openai_response(messages, @model)
 
-    # Access current run to set model and token usage (Python SDK pattern)
-    if (run = Langsmith.current_run)
       run.set_model(model: @model, provider: "openai")
       run.set_token_usage(
         input_tokens: response[:usage][:prompt_tokens],
@@ -171,24 +166,21 @@ class LLMService
         total_tokens: response[:usage][:total_tokens]
       )
       run.add_metadata(temperature: @temperature)
-    end
 
-    response[:choices].first[:message][:content]
+      response[:choices].first[:message][:content]
+    end
   end
 
-  traceable run_type: "llm", name: "llm_service.embed"
   def embed(text)
-    # Simulate embedding call
-    tokens_used = (text.length / 4.0).ceil
+    Langsmith.trace("llm_service.embed", run_type: "llm", inputs: { text_preview: text[0..30] }) do |run|
+      tokens_used = (text.length / 4.0).ceil
 
-    if (run = Langsmith.current_run)
       run.set_model(model: "text-embedding-3-small", provider: "openai")
-      # Embeddings only have input tokens, no output tokens
       run.set_token_usage(input_tokens: tokens_used)
       run.add_metadata(dimensions: 1536)
-    end
 
-    Array.new(1536) { rand(-1.0..1.0) }
+      Array.new(1536) { rand(-1.0..1.0) }
+    end
   end
 end
 
@@ -284,7 +276,7 @@ if __FILE__ == $PROGRAM_NAME
   result = trace_llm_chain("How do I trace LLM calls?")
   puts "   Response: #{result}"
 
-  puts "\n4. Using Traceable module:"
+  puts "\n4. Class-based tracing:"
   service = LLMService.new(model: "gpt-4", temperature: 0.5)
   result = service.chat([{ role: "user", content: "Hello!" }])
   puts "   Chat response: #{result}"

data/examples/openai_integration.rb

@@ -416,55 +416,49 @@ end
 
 # Example: RAG chain with OpenAI
 class RAGChain
-  include Langsmith::Traceable
-
   def initialize(knowledge_base:)
     @knowledge_base = knowledge_base
   end
 
-  traceable run_type: "chain", name: "rag_chain"
   def answer(question)
-    # Step 1: Embed the question
-    question_embedding = embed_query(question)
+    Langsmith.trace("rag_chain", run_type: "chain", inputs: { question: question }) do
+      question_embedding = embed_query(question)
 
-    # Step 2: Retrieve relevant context
-    context = retrieve_context(question_embedding)
+      context = retrieve_context(question_embedding)
 
-    # Step 3: Generate answer
-    generate_answer(question, context)
+      generate_answer(question, context)
+    end
   end
 
   private
 
-  traceable run_type: "llm", name: "embed_query"
   def embed_query(text)
-    response = TracedOpenAI.embed(input: text)
-    response.dig("data", 0, "embedding")
+    Langsmith.trace("embed_query", run_type: "llm", inputs: { text: text[0..50] }) do
+      response = TracedOpenAI.embed(input: text)
+      response.dig("data", 0, "embedding")
+    end
   end
 
-  traceable run_type: "retriever", name: "retrieve_context"
   def retrieve_context(embedding)
-    # Simulate vector search - in real app, query your vector DB
-    Langsmith.current_run&.add_metadata(
-      index: "knowledge_base",
-      top_k: 3
-    )
-
-    @knowledge_base.first(3)
+    Langsmith.trace("retrieve_context", run_type: "retriever", inputs: { top_k: 3 }) do |run|
+      run.add_metadata(index: "knowledge_base", top_k: 3)
+      @knowledge_base.first(3)
+    end
   end
 
-  traceable run_type: "llm", name: "generate_answer"
   def generate_answer(question, context)
-    messages = [
-      {
-        role: "system",
-        content: "Answer the question based on the following context:\n\n#{context.join("\n\n")}"
-      },
-      { role: "user", content: question }
-    ]
+    Langsmith.trace("generate_answer", run_type: "llm", inputs: { question: question }) do
+      messages = [
+        {
+          role: "system",
+          content: "Answer the question based on the following context:\n\n#{context.join("\n\n")}"
+        },
+        { role: "user", content: question }
+      ]
 
-    response = TracedOpenAI.chat(messages: messages, model: "gpt-4o-mini")
-    response.dig("choices", 0, "message", "content")
+      response = TracedOpenAI.chat(messages: messages, model: "gpt-4o-mini")
+      response.dig("choices", 0, "message", "content")
+    end
   end
 end
 

data/lib/langsmith/batch_processor.rb

@@ -8,27 +8,35 @@ module Langsmith
   #
   # Thread Safety:
   # - Uses AtomicBoolean for atomic start/shutdown
-  # - Uses a Mutex to protect flush_pending from concurrent access
-  # - Uses Concurrent::Array for thread-safe pending queues
+  # - Uses @pending_mutex to protect all pending array access (add + extract)
+  # - Uses @flush_mutex to ensure only one flush operation runs at a time
+  # - HTTP calls happen outside locks to avoid blocking the worker
   class BatchProcessor
     # Entry types for the queue
     CREATE = :create
     UPDATE = :update
     SHUTDOWN = :shutdown
 
-    def initialize(client: nil, batch_size: nil, flush_interval: nil)
+    def initialize(client: nil, batch_size: nil, flush_interval: nil, max_pending_entries: nil)
       config = Langsmith.configuration
       @client = client || Client.new
       @batch_size = batch_size || config.batch_size
       @flush_interval = flush_interval || config.flush_interval
+      @max_pending_entries = max_pending_entries || config.max_pending_entries
 
       @queue = Queue.new
       @running = Concurrent::AtomicBoolean.new(false)
       @worker_thread = Concurrent::AtomicReference.new(nil)
-      @pending_creates = Concurrent::Array.new
-      @pending_updates = Concurrent::Array.new
-      @flush_task = nil
+
+      # Use regular arrays protected by mutex (simpler than Concurrent::Array)
+      @pending_creates = []
+      @pending_updates = []
+      @pending_mutex = Mutex.new
+
+      # Separate mutex for flush operations to prevent concurrent flushes
       @flush_mutex = Mutex.new
+
+      @flush_task = nil
       @shutdown_hook_registered = false
     end
 
@@ -66,7 +74,14 @@ module Langsmith
     end
 
     def flush
-      flush_pending
+      ensure_started
+
+      # Drain anything currently in the queue into pending, then flush.
+      # Run a second drain pass to catch items enqueued while we were flushing.
+      2.times do
+        drain_queue_non_blocking
+        flush_pending
+      end
     end
 
     def running?
@@ -82,15 +97,20 @@ module Langsmith
       end
 
       ensure_started
-      # Use to_h for creates (full data), to_update_h for updates (minimal PATCH payload)
+
+      # Snapshot run data on the calling thread to capture state at enqueue time.
+      # This ensures CREATE captures initial state and UPDATE captures final state.
+      # Trade-off: serialization happens on the hot path, but semantics are correct.
       run_data = type == CREATE ? run.to_h : run.to_update_h
       @queue << { type: type, run_data: run_data, tenant_id: run.tenant_id }
+      trim_buffer_if_needed
     end
 
     def create_worker_thread
       Thread.new { worker_loop }.tap do |t|
         t.abort_on_exception = false
-        t.report_on_exception = false
+        # Enable reporting so we at least see errors in logs
+        t.report_on_exception = true
       end
     end
 
@@ -124,16 +144,32 @@ module Langsmith
 
         flush_if_batch_full
       rescue StandardError => e
-        log_error("Batch processor error: #{e.message}")
+        log_error("Batch processor error: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
       end
     end
 
+    # Non-blocking drain of the queue into pending arrays.
+    # Returns true if any entries were drained.
+    def drain_queue_non_blocking
+      drained = false
+
+      loop do
+        entry = pop_queue_non_blocking
+        break unless entry
+
+        process_entry(entry) unless entry[:type] == SHUTDOWN
+        drained = true
+      end
+
+      drained
+    end
+
     def process_entry(entry)
       case entry[:type]
       when CREATE
-        @pending_creates << build_pending_entry(entry)
+        add_pending(:creates, entry)
       when UPDATE
-        @pending_updates << build_pending_entry(entry)
+        add_pending(:updates, entry)
       when SHUTDOWN
         drain_queue
         flush_pending
@@ -141,8 +177,17 @@ module Langsmith
       end
     end
 
-    def build_pending_entry(entry)
-      { data: entry[:run_data], tenant_id: entry[:tenant_id] }
+    # Thread-safe add to pending arrays
+    def add_pending(type, entry)
+      pending_entry = { data: entry[:run_data], tenant_id: entry[:tenant_id] }
+      @pending_mutex.synchronize do
+        case type
+        when :creates
+          @pending_creates << pending_entry
+        when :updates
+          @pending_updates << pending_entry
+        end
+      end
     end
 
     def drain_queue
@@ -172,35 +217,49 @@ module Langsmith
       pending_count.positive?
     end
 
+    # Approximate count - doesn't need to be perfectly synchronized
+    # since it's just used for heuristic batch-full checks
     def pending_count
-      @pending_creates.size + @pending_updates.size
+      @pending_mutex.synchronize do
+        @pending_creates.size + @pending_updates.size
+      end
     end
 
     def flush_pending
+      # Only one flush at a time
       @flush_mutex.synchronize do
-        creates = extract_all(@pending_creates)
-        updates = extract_all(@pending_updates)
+        # Atomically extract all pending items
+        creates, updates = extract_pending
 
         return if creates.empty? && updates.empty?
 
-        send_batches(creates, updates)
+        # HTTP calls happen outside @pending_mutex to avoid blocking the worker
+        failed_creates, failed_updates = send_batches(creates, updates)
+
+        requeue_failed(failed_creates, failed_updates)
       end
     end
 
-    def extract_all(array)
-      result = []
-      result << array.shift until array.empty?
-      result
-    rescue ThreadError
-      result
+    # Atomically extract and clear pending arrays
+    # Returns [creates, updates] arrays
+    def extract_pending
+      @pending_mutex.synchronize do
+        creates = @pending_creates.dup
+        updates = @pending_updates.dup
+        @pending_creates.clear
+        @pending_updates.clear
+        [creates, updates]
+      end
     end
 
     def send_batches(creates, updates)
       by_tenant = group_by_tenant(creates, updates)
 
       # Send POSTs first, then PATCHes (LangSmith needs runs created before updating)
-      send_batch_type(by_tenant, :creates, :post_runs)
-      send_batch_type(by_tenant, :updates, :patch_runs)
+      failed_creates = send_batch_type(by_tenant, :creates, :post_runs)
+      failed_updates = send_batch_type(by_tenant, :updates, :patch_runs)
+
+      [failed_creates, failed_updates]
     end
 
     def group_by_tenant(creates, updates)
@@ -211,23 +270,83 @@ module Langsmith
     end
 
     def send_batch_type(by_tenant, type_key, param_key)
+      failed = []
+
       by_tenant[type_key].each do |tenant_id, entries|
         runs = entries.map { |e| e[:data] }
         next if runs.empty?
 
-        send_to_api(tenant_id, param_key, runs)
+        success = send_to_api(tenant_id, param_key, runs)
+        failed.concat(entries) unless success
       end
+
+      failed
     end
 
     def send_to_api(tenant_id, param_key, runs)
       params = { post_runs: [], patch_runs: [], tenant_id: tenant_id }
       params[param_key] = runs
 
-      @client.batch_ingest_raw(**params)
+      @client.batch_ingest(**params)
+      true
     rescue Client::APIError => e
       log_error("Failed to send #{param_key} for tenant #{tenant_id}: #{e.message}", force: true)
+      false
     rescue StandardError => e
-      log_error("Unexpected error sending #{param_key}: #{e.message}")
+      # Force logging so unexpected failures don't silently drop traces
+      log_error("Unexpected error sending #{param_key}: #{e.message}", force: true)
+      false
+    end
+
+    def requeue_failed(failed_creates, failed_updates)
+      return if failed_creates.empty? && failed_updates.empty?
+
+      @pending_mutex.synchronize do
+        @pending_creates.concat(failed_creates)
+        @pending_updates.concat(failed_updates)
+      end
+
+      trim_buffer_if_needed
+    end
+
+    def trim_buffer_if_needed
+      return unless @max_pending_entries
+
+      while current_buffer_size > @max_pending_entries
+        drop_one_entry
+      end
+    end
+
+    def current_buffer_size
+      queue_size = @queue.size
+      pending_size = @pending_mutex.synchronize { @pending_creates.size + @pending_updates.size }
+      queue_size + pending_size
+    end
+
+    def drop_one_entry
+      entry = pop_queue_non_blocking
+      entry ||= pop_pending_non_blocking
+      log_dropped(entry) if entry
+    end
+
+    def pop_queue_non_blocking
+      @queue.pop(true)
+    rescue ThreadError
+      nil
+    end
+
+    def pop_pending_non_blocking
+      @pending_mutex.synchronize do
+        return @pending_creates.shift unless @pending_creates.empty?
+        return @pending_updates.shift unless @pending_updates.empty?
+      end
+      nil
+    end
+
+    def log_dropped(entry)
+      return unless ENV["LANGSMITH_DEBUG"]
+
+      log_error("Dropped run entry due to max_pending_entries cap (type: #{entry[:type]}, tenant: #{entry[:tenant_id]})")
     end
 
     def log_error(message, force: false)

data/lib/langsmith/client.rb

@@ -66,29 +66,6 @@ module Langsmith
       patch("/runs/#{run.id}", run.to_h, tenant_id: run.tenant_id)
     end
 
-    # Batch create/update runs.
-    # All runs in a batch should have the same tenant_id for optimal performance.
-    #
-    # @param post_runs [Array<Run>] runs to create
-    # @param patch_runs [Array<Run>] runs to update
-    # @param tenant_id [String, nil] tenant ID (inferred from runs if not provided)
-    # @return [Hash, nil] API response
-    # @raise [APIError] if the request fails
-    def batch_ingest(post_runs: [], patch_runs: [], tenant_id: nil)
-      return if post_runs.empty? && patch_runs.empty?
-
-      payload = {}
-      payload[:post] = post_runs.map(&:to_h) unless post_runs.empty?
-      payload[:patch] = patch_runs.map(&:to_h) unless patch_runs.empty?
-
-      # Use tenant_id from first run if not explicitly provided
-      effective_tenant_id = tenant_id ||
-                            post_runs.first&.tenant_id ||
-                            patch_runs.first&.tenant_id
-
-      post("/runs/batch", payload, tenant_id: effective_tenant_id)
-    end
-
     # Batch create/update runs using pre-serialized hashes.
     # Used by BatchProcessor which snapshots run data at enqueue time.
     #
@@ -97,7 +74,7 @@ module Langsmith
     # @param tenant_id [String, nil] tenant ID for the request
     # @return [Hash, nil] API response
     # @raise [APIError] if the request fails
-    def batch_ingest_raw(post_runs: [], patch_runs: [], tenant_id: nil)
+    def batch_ingest(post_runs: [], patch_runs: [], tenant_id: nil)
       return if post_runs.empty? && patch_runs.empty?
 
       payload = {}

data/lib/langsmith/configuration.rb

@@ -42,6 +42,9 @@ module Langsmith
     # @return [String, nil] Tenant ID for multi-tenant scenarios
     attr_accessor :tenant_id
 
+    # @return [Integer, nil] Maximum buffered run entries (queue + pending); nil means unlimited
+    attr_accessor :max_pending_entries
+
     def initialize
       @api_key = ENV.fetch("LANGSMITH_API_KEY", nil)
       @endpoint = ENV.fetch("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
@@ -52,6 +55,7 @@ module Langsmith
       @timeout = ENV.fetch("LANGSMITH_TIMEOUT", 10).to_i
       @max_retries = ENV.fetch("LANGSMITH_MAX_RETRIES", 3).to_i
       @tenant_id = ENV.fetch("LANGSMITH_TENANT_ID", nil)
+      @max_pending_entries = ENV.fetch("LANGSMITH_MAX_PENDING_ENTRIES", nil)&.to_i
     end
 
     # Returns whether tracing is enabled in configuration.

data/lib/langsmith/version.rb

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

data/lib/langsmith.rb

@@ -8,7 +8,6 @@ require_relative "langsmith/context"
 require_relative "langsmith/client"
 require_relative "langsmith/batch_processor"
 require_relative "langsmith/run_tree"
-require_relative "langsmith/traceable"
 
 module Langsmith
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: langsmith-sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Felipe Cabezudo
@@ -101,7 +101,6 @@ files:
 - lib/langsmith/railtie.rb
 - lib/langsmith/run.rb
 - lib/langsmith/run_tree.rb
-- lib/langsmith/traceable.rb
 - lib/langsmith/version.rb
 homepage: https://github.com/felipekb/langsmith-ruby-sdk
 licenses:

data/lib/langsmith/traceable.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-module Langsmith
-  # Module that provides method decoration for automatic tracing.
-  # Include this module in your class and use the `traceable` class method
-  # to mark methods for tracing.
-  #
-  # @example
-  #   class MyService
-  #     include Langsmith::Traceable
-  #
-  #     traceable run_type: "llm"
-  #     def call_llm(prompt)
-  #       # automatically traced
-  #     end
-  #
-  #     traceable run_type: "tool", name: "search"
-  #     def search(query)
-  #       # traced with custom name
-  #     end
-  #
-  #     traceable run_type: "chain", tenant_id: "tenant-123"
-  #     def process_for_tenant(data)
-  #       # traced to specific tenant
-  #     end
-  #   end
-  module Traceable
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      # Marks the next defined method as traceable
-      def traceable(run_type: "chain", name: nil, metadata: nil, tags: nil, tenant_id: nil)
-        @pending_traceable_options = {
-          run_type: run_type,
-          name: name,
-          metadata: metadata,
-          tags: tags,
-          tenant_id: tenant_id
-        }
-      end
-
-      def method_added(method_name)
-        super
-
-        return unless @pending_traceable_options
-
-        options = @pending_traceable_options
-        @pending_traceable_options = nil
-
-        # Don't wrap private/protected methods that start with underscore
-        return if method_name.to_s.start_with?("_langsmith_")
-
-        wrap_method(method_name, options)
-      end
-
-      private
-
-      def wrap_method(method_name, options)
-        original_method = instance_method(method_name)
-        trace_name = options[:name] || "#{name}##{method_name}"
-
-        # Remove original method to avoid "method redefined" warning
-        remove_method(method_name)
-
-        define_method(method_name) do |*args, **kwargs, &block|
-          Langsmith.trace(
-            trace_name,
-            run_type: options[:run_type],
-            inputs: build_trace_inputs(args, kwargs, original_method),
-            metadata: options[:metadata],
-            tags: options[:tags],
-            tenant_id: options[:tenant_id]
-          ) do |_run|
-            if kwargs.empty?
-              original_method.bind(self).call(*args, &block)
-            else
-              original_method.bind(self).call(*args, **kwargs, &block)
-            end
-          end
-        end
-      end
-    end
-
-    private
-
-    def build_trace_inputs(args, kwargs, method)
-      params = method.parameters
-      inputs = {}
-
-      # Map positional arguments
-      args.each_with_index do |arg, index|
-        param = params[index]
-        param_name = param ? param[1] : "arg#{index}"
-        inputs[param_name] = serialize_input(arg)
-      end
-
-      # Map keyword arguments
-      kwargs.each do |key, value|
-        inputs[key] = serialize_input(value)
-      end
-
-      inputs
-    end
-
-    def serialize_input(value)
-      case value
-      when String, Numeric, TrueClass, FalseClass, NilClass
-        value
-      when Array
-        value.map { |v| serialize_input(v) }
-      when Hash
-        value.transform_values { |v| serialize_input(v) }
-      else
-        value.to_s
-      end
-    end
-  end
-end