Add input/output support for traces

Traces were missing input/output fields, causing them to appear as
null/undefined in the Langfuse UI. This change adds full support for
trace input/output via both parameters and setter methods.

Changes:
- Add input/output parameters to Tracer#trace and Langfuse.trace
- Add input=/output= setter methods to Trace class
- Update exporter to parse and include input/output in trace-create events
- Add comprehensive end-to-end tests verifying the fix

Traces can now capture input/output in two ways:
1. Via parameters: Langfuse.trace(name: "...", input: {...}, output: {...})
2. Via setters: trace.input = {...}; trace.output = {...}

Author: NoahFisher

lib/langfuse.rb

@@ -90,6 +90,8 @@ def tracer
     # @param name [String] Name of the trace
     # @param user_id [String, nil] Optional user ID
     # @param session_id [String, nil] Optional session ID
+    # @param input [Object, nil] Optional input data (will be JSON-encoded)
+    # @param output [Object, nil] Optional output data (will be JSON-encoded)
     # @param metadata [Hash, nil] Optional metadata hash
     # @param tags [Array<String>, nil] Optional tags array
     # @param context [OpenTelemetry::Context, nil] Optional parent context for distributed tracing
@@ -98,7 +100,7 @@ def tracer
     # @return [Object] The return value of the block
     #
     # @example
-    #   Langfuse.trace(name: "user-request", user_id: "user-123") do |trace|
+    #   Langfuse.trace(name: "user-request", user_id: "user-123", input: { query: "..." }) do |trace|
     #     trace.span(name: "database-query") do |span|
     #       # Do work
     #     end
@@ -108,11 +110,13 @@ def tracer
     #     end
     #   end
     #
-    def trace(name:, user_id: nil, session_id: nil, metadata: nil, tags: nil, context: nil, &)
+    def trace(name:, user_id: nil, session_id: nil, input: nil, output: nil, metadata: nil, tags: nil, context: nil, &)
       tracer.trace(
         name: name,
         user_id: user_id,
         session_id: session_id,
+        input: input,
+        output: output,
         metadata: metadata,
         tags: tags,
         context: context,

lib/langfuse/exporter.rb

@@ -130,6 +130,8 @@ def create_trace_event(span_data, attributes)
           name: span_data.name,
           user_id: attributes["langfuse.user_id"],
           session_id: attributes["langfuse.session_id"],
+          input: parse_json_attribute(attributes["langfuse.input"]),
+          output: parse_json_attribute(attributes["langfuse.output"]),
           metadata: parse_json_attribute(attributes["langfuse.metadata"]),
           tags: parse_json_attribute(attributes["langfuse.tags"]),
           timestamp: format_timestamp(span_data.start_timestamp)

lib/langfuse/trace.rb

@@ -132,6 +132,54 @@ def inject_context
       carrier
     end
 
+    # Set the input of this trace
+    #
+    # @param value [Object] The input value (will be JSON-encoded)
+    # @return [void]
+    #
+    # @example
+    #   trace.input = { query: "What is Ruby?" }
+    #
+    def input=(value)
+      @otel_span.set_attribute("langfuse.input", value.to_json)
+    end
+
+    # Set the output of this trace
+    #
+    # @param value [Object] The output value (will be JSON-encoded)
+    # @return [void]
+    #
+    # @example
+    #   trace.output = { answer: "Ruby is a programming language" }
+    #
+    def output=(value)
+      @otel_span.set_attribute("langfuse.output", value.to_json)
+    end
+
+    # Set metadata for this trace
+    #
+    # @param value [Hash] Metadata hash (will be JSON-encoded)
+    # @return [void]
+    #
+    # @example
+    #   trace.metadata = { source: "api", cache: "miss" }
+    #
+    def metadata=(value)
+      @otel_span.set_attribute("langfuse.metadata", value.to_json)
+    end
+
+    # Set the level of this trace
+    #
+    # @param value [String] Level (debug, default, warning, error)
+    # @return [void]
+    #
+    # @example
+    #   trace.level = "warning"
+    #
+    def level=(value)
+      @otel_span.set_attribute("langfuse.level", value)
+    end
+
     private
 
     # Build OTel attributes for a span

lib/langfuse/tracer.rb

@@ -29,6 +29,8 @@ def initialize(otel_tracer: nil)
     # @param name [String] Name of the trace
     # @param user_id [String, nil] Optional user ID
     # @param session_id [String, nil] Optional session ID
+    # @param input [Object, nil] Optional input data (will be JSON-encoded)
+    # @param output [Object, nil] Optional output data (will be JSON-encoded)
     # @param metadata [Hash, nil] Optional metadata hash
     # @param tags [Array<String>, nil] Optional tags array
     # @param context [OpenTelemetry::Context, nil] Optional parent context for distributed tracing
@@ -37,16 +39,19 @@ def initialize(otel_tracer: nil)
     # @return [Object] The return value of the block
     #
     # @example
-    #   tracer.trace(name: "user-request", user_id: "user-123") do |trace|
+    #   tracer.trace(name: "user-request", user_id: "user-123", input: { query: "..." }) do |trace|
     #     trace.span(name: "database-query") do |span|
     #       # Do work
     #     end
     #   end
     #
-    def trace(name:, user_id: nil, session_id: nil, metadata: nil, tags: nil, context: nil, &block)
+    def trace(name:, user_id: nil, session_id: nil, input: nil, output: nil, metadata: nil, tags: nil, context: nil,
+              &block)
       attributes = build_trace_attributes(
         user_id: user_id,
         session_id: session_id,
+        input: input,
+        output: output,
         metadata: metadata,
         tags: tags
       )
@@ -73,14 +78,18 @@ def default_tracer
     #
     # @param user_id [String, nil]
     # @param session_id [String, nil]
+    # @param input [Object, nil]
+    # @param output [Object, nil]
     # @param metadata [Hash, nil]
     # @param tags [Array<String>, nil]
     # @return [Hash]
-    def build_trace_attributes(user_id:, session_id:, metadata:, tags:)
+    def build_trace_attributes(user_id:, session_id:, input:, output:, metadata:, tags:)
       {
         "langfuse.type" => "trace",
         "langfuse.user_id" => user_id,
         "langfuse.session_id" => session_id,
+        "langfuse.input" => input&.to_json,
+        "langfuse.output" => output&.to_json,
         "langfuse.metadata" => metadata&.to_json,
         "langfuse.tags" => tags&.to_json
       }.compact

spec/langfuse/end_to_end_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "opentelemetry/sdk"
+
+RSpec.describe "End-to-End Langfuse Integration" do
+  let(:public_key) { "pk_test_123" }
+  let(:secret_key) { "sk_test_456" }
+  let(:base_url) { "https://api.langfuse.test" }
+
+  # Capture the actual request body sent to Langfuse
+  let(:captured_request_body) { [] }
+
+  before do
+    # Configure Langfuse with tracing enabled
+    Langfuse.configure do |config|
+      config.public_key = public_key
+      config.secret_key = secret_key
+      config.base_url = base_url
+      config.tracing_enabled = true
+    end
+
+    # Stub the ingestion API and capture request body
+    stub_request(:post, "#{base_url}/api/public/ingestion")
+      .to_return do |request|
+        captured_request_body << JSON.parse(request.body)
+        { status: 200, body: {}.to_json }
+      end
+  end
+
+  after do
+    Langfuse.reset!
+  end
+
+  describe "Trace with Generation" do
+    it "sends correct payload to Langfuse API" do
+      # Simulate the spam-detection script
+      Langfuse.trace(name: "spam-detection", user_id: "test-user") do |trace|
+        messages = [
+          { role: :system, content: "You are a spam detector" },
+          { role: :user, content: "Buy meds!" }
+        ]
+
+        trace.generation(
+          name: "classify",
+          model: "gpt-4",
+          input: messages
+        ) do |gen|
+          gen.output = "95"
+          gen.usage = {
+            prompt_tokens: 50,
+            completion_tokens: 2,
+            total_tokens: 52
+          }
+        end
+      end
+
+      # Force flush to send the data
+      Langfuse.force_flush
+
+      # Verify request was made
+      expect(WebMock).to have_requested(:post, "#{base_url}/api/public/ingestion").at_least_once
+
+      # Debug: Print the captured payloads
+      puts "\n=== Captured Request Bodies ==="
+      captured_request_body.each_with_index do |body, idx|
+        puts "\n--- Request #{idx + 1} ---"
+        puts JSON.pretty_generate(body)
+      end
+      puts "=== End Captured Bodies ===\n"
+
+      # Verify the payloads
+      all_events = captured_request_body.flat_map { |req| req["batch"] }
+
+      # Should have 2 events: trace-create and generation-create
+      expect(all_events.length).to be >= 2
+
+      trace_event = all_events.find { |e| e["type"] == "trace-create" }
+      generation_event = all_events.find { |e| e["type"] == "generation-create" }
+
+      expect(trace_event).not_to be_nil
+      expect(generation_event).not_to be_nil
+
+      # Verify trace data
+      expect(trace_event["body"]["name"]).to eq("spam-detection")
+      expect(trace_event["body"]["user_id"]).to eq("test-user")
+
+      # Verify generation data
+      expect(generation_event["body"]["name"]).to eq("classify")
+      expect(generation_event["body"]["model"]).to eq("gpt-4")
+
+      # THIS IS THE KEY TEST: Check if input/output are present and parsed correctly
+      puts "\n=== Generation Event Body ==="
+      puts JSON.pretty_generate(generation_event["body"])
+
+      # Input should be the messages array (parsed from JSON)
+      expect(generation_event["body"]["input"]).to eq([
+                                                        { "role" => "system", "content" => "You are a spam detector" },
+                                                        { "role" => "user", "content" => "Buy meds!" }
+                                                      ])
+
+      # Output should be the string "95" (parsed from JSON)
+      expect(generation_event["body"]["output"]).to eq("95")
+
+      # Usage should be the hash (parsed from JSON)
+      expect(generation_event["body"]["usage"]).to eq({
+                                                        "prompt_tokens" => 50,
+                                                        "completion_tokens" => 2,
+                                                        "total_tokens" => 52
+                                                      })
+    end
+
+    it "supports trace input/output via parameters" do
+      # Test traces with input/output passed as parameters
+      Langfuse.trace(
+        name: "test-trace",
+        user_id: "user-123",
+        input: { query: "What is Ruby?" },
+        output: { answer: "A programming language" },
+        metadata: { foo: "bar" }
+      ) do |trace|
+        trace.span(name: "step-1", input: { query: "test" }) do |span|
+          span.output = { result: "success" }
+        end
+      end
+
+      Langfuse.force_flush
+
+      all_events = captured_request_body.flat_map { |req| req["batch"] }
+
+      trace_event = all_events.find { |e| e["type"] == "trace-create" }
+      span_event = all_events.find { |e| e["type"] == "span-create" }
+
+      # Trace should have input/output
+      expect(trace_event["body"]["input"]).to eq({ "query" => "What is Ruby?" })
+      expect(trace_event["body"]["output"]).to eq({ "answer" => "A programming language" })
+      expect(trace_event["body"]["metadata"]).to eq({ "foo" => "bar" })
+
+      # Span should have input/output
+      expect(span_event["body"]["input"]).to eq({ "query" => "test" })
+      expect(span_event["body"]["output"]).to eq({ "result" => "success" })
+    end
+
+    it "supports trace input/output via setters" do
+      # Test traces with input/output set via setters
+      Langfuse.trace(name: "test-trace-2", user_id: "user-456") do |trace|
+        trace.input = { request: "calculate 2+2" }
+        trace.output = { result: 4 }
+        trace.metadata = { calculator: "v1" }
+      end
+
+      Langfuse.force_flush
+
+      all_events = captured_request_body.flat_map { |req| req["batch"] }
+
+      trace_event = all_events.find { |e| e["type"] == "trace-create" && e["body"]["name"] == "test-trace-2" }
+
+      # Trace should have input/output set via setters
+      expect(trace_event["body"]["input"]).to eq({ "request" => "calculate 2+2" })
+      expect(trace_event["body"]["output"]).to eq({ "result" => 4 })
+      expect(trace_event["body"]["metadata"]).to eq({ "calculator" => "v1" })
+    end
+  end
+end