llm_logs 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8982c29ec3f53e2271e24f78065472f3f71b15828449dd51cda1154122cb8d6f
-  data.tar.gz: 2a2026e3441b16b61c36497689a7d468f09987bfb0c85c95aebb641ba3ee9d94
+  metadata.gz: c131b25cf1499cbebd755808d206f17e7c4dc4199fe18a7d282cabef947b349f
+  data.tar.gz: fadedd362588224fad8fc191dc6f9a3ee4d65746ed1d86f239b37e228b448606
 SHA512:
-  metadata.gz: d3d62b8c8d71bb12639ef74895d53e2974aba1eca3e4d219bce6387f790cb7712ac2ca46ea24e72c7940bb2970ecc04af976802d7a7d1c2f758bc507a392e3aa
-  data.tar.gz: 9dfdbe34061fe8b748fda1ca4ad75f8646e57030c264549b91da0cd0b0314577b42b4b0fef8bfa87b336cbac9c2b95bf5d10bf92686c5548780539751b14402b
+  metadata.gz: d94d3962f820cce448da3171f364eeaea2995a707a8fd79e863fae6b9889db321e0ccf6bcead6f12ac48aa50709178e5c8dc2de858db6e111aa4be8ba7bc5cce
+  data.tar.gz: 8237d89556f129e2010ee04229d85f2ebe03d3bd11ad7799e1150a3d7c88134c1b4c63fe54e8555f9a3e53b1119e604332b184bb787c9586d87559db26453343

data/README.md

@@ -209,16 +209,7 @@ Running the task creates missing prompts, updates metadata, and creates a new pr
 
 Send latency-insensitive requests through a provider's Batch API for roughly half the cost. LlmLogs persists each request, groups pending requests into a provider batch, reconciles results, and records a trace per request — so batched work shows up in the dashboard alongside synchronous calls.
 
-Two batch backends are supported, selected **per model**:
-
-- **[OpenAI Responses Batch API](https://platform.openai.com/docs/guides/batch)** via [`ruby_llm-responses_api`](https://rubygems.org/gems/ruby_llm-responses_api) — the default for OpenAI models.
-- **[AWS Bedrock Batch API](#aws-bedrock-batches)** (`CreateModelInvocationJob`) for Anthropic Claude models.
-
-Add the OpenAI provider to your app's Gemfile:
-
-```ruby
-gem "ruby_llm-responses_api"
-```
+Batching runs on the **[AWS Bedrock Batch API](#aws-bedrock-batches)** (`CreateModelInvocationJob`) for Anthropic Claude models. Models Bedrock does not serve are not batchable; run them synchronously.
 
 ### Enqueue a Request
 
@@ -227,10 +218,10 @@ Requests are persisted immediately and grouped by `purpose` + `model` when submi
 ```ruby
 LlmLogs::Batch.enqueue(
   purpose: "chat_summary",
-  model: "gpt-4.1-mini",
+  model: "anthropic.claude-haiku-4-5-20251001-v1:0",
   instructions: "Summarize the conversation in two sentences.",
   input: conversation_text,
-  schema: SummarySchema,          # optional RubyLLM::Schema for structured output
+  schema: SUMMARY_SCHEMA,          # optional JSON schema Hash for structured output
   routing: { conversation_id: 42 }, # your keys, echoed into the trace metadata
   temperature: 0.2                  # optional
 )
@@ -247,7 +238,8 @@ Register one handler per `purpose`. The gem owns the batch lifecycle; your app o
 LlmLogs.register_batch_handler("chat_summary", ChatSummaryHandler.new)
 
 class ChatSummaryHandler
-  # Called once a request succeeds. `message` is the RubyLLM::Message.
+  # Called once a request succeeds. `message` is a `LlmLogs::Batch::Adapters::Bedrock::Result`
+  # (content, input_tokens, output_tokens, model_id).
   def call(request, message)
     Conversation.find(request.routing["conversation_id"])
       .update!(summary: message.content)
@@ -302,7 +294,7 @@ LlmLogs.configuration.bedrock_batch = LlmLogs::Configuration::BedrockBatch.new(
 LlmLogs.register_batch_adapter(:bedrock, LlmLogs::Batch::Adapters::Bedrock.new)
 ```
 
-Provider selection is per model: `LlmLogs::Batch.batch_provider_for(model)` returns `:bedrock` when the adapter is registered and `model_matcher` matches, otherwise the OpenAI backend when the model resolves there, otherwise `nil` (not batchable — run it synchronously). Bedrock enforces a **minimum records per job**, so check `LlmLogs::Batch.min_records_for(model)` and fall back to a synchronous call when a batch would be under the floor.
+Provider selection is per model: `LlmLogs::Batch.batch_provider_for(model)` returns `:bedrock` when the adapter is registered and `model_matcher` matches, otherwise `nil` (not batchable — run it synchronously). Bedrock enforces a **minimum records per job**, so check `LlmLogs::Batch.min_records_for(model)` and fall back to a synchronous call when a batch would be under the floor.
 
 The adapter builds its AWS clients from the ambient credential chain by default; inject your own to authenticate explicitly:
 
@@ -330,16 +322,37 @@ Browse traces and manage prompts at `/llm_logs`.
 ```ruby
 LlmLogs.setup do |config|
   config.enabled = true                                      # master switch for logging
-  config.auto_instrument = true                              # auto-prepend on RubyLLM::Chat
+  config.auto_instrument = true                              # subscribe to ruby_llm notifications (needs RubyLLM.config.instrumenter = ActiveSupport::Notifications)
   config.retention_days = 30                                 # for future cleanup job
   config.prompts_source_path = Rails.root.join("db/data/prompts")
   config.prompt_subfolders = %w[skills fragments templates]
   config.batch_enabled = true                                # enable the batch API integration
-  config.batch_provider = :openai_responses                  # default (OpenAI) backend; Bedrock is registered separately (see Batches)
   config.page_size = 50                                      # rows per page on all index pages
 end
 ```
 
+## ruby_llm 2.0 integration
+
+With `auto_instrument` on, LlmLogs subscribes to ruby_llm's `chat.ruby_llm` and `tool_call.ruby_llm` notifications: one `llm` span per provider round and one tool span per tool call, all siblings under the trace. Tokens and cost come from each round's usage entries. This requires `RubyLLM.config.instrumenter` to be `ActiveSupport::Notifications`; the Railtie sets that default, and `LlmLogs::Instrumentation::RubyLlmChat.install!` sets it when unset.
+
+### Patches for ruby_llm 2.0.x
+
+The engine prepends five fixes (`LlmLogs::RubyLLMPatches`) that ruby_llm 2.0.0 lacks. Each one backports an upstream pull request, so dropping it once a ruby_llm release includes that PR changes no behaviour (exceptions are noted). They install only on ruby_llm >= 2.0.0, and log a warning on 2.1 or later so you re-check them.
+
+| Patch | Upstream PR |
+|---|---|
+| BedrockSigV4, RetrySSLError | [crmne/ruby_llm#1024](https://github.com/crmne/ruby_llm/pull/1024) |
+| ConverseReasoningConfig, ConverseClaudeAdaptiveThinking | [crmne/ruby_llm#1025](https://github.com/crmne/ruby_llm/pull/1025) |
+| ConverseForeignReasoning | [crmne/ruby_llm#1026](https://github.com/crmne/ruby_llm/pull/1026) |
+
+- **BedrockSigV4** ([#1024](https://github.com/crmne/ruby_llm/pull/1024), "Sign each Bedrock attempt when it is sent") re-signs every Bedrock attempt at send time, over the body being sent, and removes an `X-Amz-Security-Token` the new signature no longer carries. Upstream 2.0.0 signs once before the retry middleware, so a retry after a long timeout replays an expired signature (403 "Signature expired"). Drop when a ruby_llm release includes #1024.
+- **RetrySSLError** ([#1024](https://github.com/crmne/ruby_llm/pull/1024), "Retry requests that fail with a TLS error") adds `Faraday::SSLError` (for example "SSL_connect ... unexpected eof") to the retried exceptions. This is the same trade-off ruby_llm already accepts for read timeouts: a request that reached the server may be sent twice. ruby_llm's `retry_if` still refuses to retry requests marked non-idempotent and streams that already delivered content. Drop when a ruby_llm release includes #1024.
+- **ConverseReasoningConfig** ([#1025](https://github.com/crmne/ruby_llm/pull/1025), "Send reasoning_config to models that publish it") sends a reasoning effort on Bedrock Converse as `additionalModelRequestFields: {reasoning_config: "<effort>"}` (including `none`, which is also what `with_thinking(false)` resolves to for these models) when the model's Converse `additionalRequestFieldsSchema`, or that of another registry entry for the same foundation model, publishes a `reasoning_config` enum (OpenAI GPT 5.6/6 Astra, xAI Grok 4.6, ...). Upstream 2.0.0 sends `reasoning_effort`, which Bedrock rejects for GPT (400 unknown_parameter). Thinking turned off, budgets, Claude, Nova, and gpt-oss are unchanged. Beyond #1025, OpenAI GPT ids with no published schema (ruby_llm 2.0.0's registry lacks GPT-6 Sol/Luna) get the same shape, under any region prefix. Drop when a ruby_llm release includes #1025; that fallback goes with it, so first check that the registry you run publishes the schema for every GPT id you use (or add `metadata.converse.additionalRequestFieldsSchema` to your catalog entry), or those ids go back to `reasoning_effort`.
+- **ConverseClaudeAdaptiveThinking** ([#1025](https://github.com/crmne/ruby_llm/pull/1025), "Think adaptively on adaptive-only Claude via Converse") sends adaptive thinking to adaptive-only Claude models on Bedrock Converse (the registry advertises an `effort` option and no `budget_tokens` option: Sonnet 5, Opus 4.7/4.8/5, Fable 5) as `additionalModelRequestFields: {thinking: {type: "adaptive"}, output_config: {effort: ...}}` (every advertised tier, `xhigh` and `max` included; `{thinking: {type: "adaptive"}}` alone when no effort is set, as for `with_thinking(true)` or a `display` alone; nothing for `none`; no `display` is sent). Upstream 2.0.0 sends a fixed `reasoning_config` budget, which these models reject ("thinking.type.enabled" is not supported for this model). Any budget, thinking turned off, budget-style Claude (Haiku 4.5, Sonnet 4.6), and other vendors are unchanged. An unregistered id takes its reasoning options from a registry entry for the same foundation model. Drop when a ruby_llm release includes #1025.
+- **ConverseForeignReasoning** ([#1026](https://github.com/crmne/ruby_llm/pull/1026), "Drop Bedrock reasoning another model family produced" and "Give application inference profiles no vendor") replays a message's reasoning only to a model of the same family on Bedrock Converse. Upstream 2.0.0 replays every assistant message's reasoning to whatever model is next, and Claude and GPT are both the `bedrock` provider: a chat Claude answered and GPT continues fails with "This model doesn't support the reasoningContent.reasoningText.text field", and a chat GPT answered and Claude continues hands Claude GPT's encrypted reasoning. A model's family is `anthropic`, `openai`, or the vendor segment of any other Bedrock id (`amazon`, `meta`, ...), whatever its region prefix; an application inference profile ARN names no family, even with a dot in its id (`.../application-inference-profile/team.prod`). The producer is `RubyLLM::Message#model` (for a persisted message, the model of its last successful usage entry). Reasoning from another family is dropped. Anthropic targets otherwise get upstream's replay unchanged, and so does a target that names no family. **This patch is stricter than #1026 on purpose:** a non-Anthropic target whose producer is unknown or of the same family gets only the `redactedContent` blocks stored in `raw_reasoning["converse"]` (GPT's own encrypted reasoning across tool-call rounds), never `reasoningText` or the thinking text/signature fallback, where #1026 replays them all. Drop when a ruby_llm release includes #1026, accepting that looser replay (or keep the stricter rule as a patch of its own).
+
+Not backported: #1025's first commit ("Recognise the in. Bedrock inference profile prefix"), which adds `in` to `Converse::REGION_PREFIXES` and also changes region rewriting and Mantle routing. The patches here match ids under any region prefix instead.
+
 ## Requirements
 
 - Rails 8.0+
@@ -349,3 +362,9 @@ end
 ## License
 
 MIT
+
+## Database support
+
+Prompts, prompt versions, tag filters, traces, spans, and their UI support PostgreSQL and SQLite. PostgreSQL retains JSONB and array tags; SQLite uses JSON columns and `json_each` for exact tag matching. Provider batch execution requires PostgreSQL; direct calls and jobs raise `LlmLogs::Batch::UnsupportedAdapter` on SQLite. `LlmLogs::Batch.supported_adapter?` reports the capability.
+
+Run the shared SQLite tests with `LLM_LOGS_DATABASE=sqlite bundle exec rspec`; PostgreSQL remains the default. SQLite migrations run from the gem's install chain before tests. `script/verify_migrations.rb` verifies install, rollback, and schema reload **only on a disposable database** with `LLM_LOGS_DISPOSABLE_DATABASE=1` and an explicit `DATABASE_URL`.

data/app/jobs/llm_logs/batch/flush_job.rb

@@ -4,6 +4,7 @@ module LlmLogs
       queue_as :default
 
       def perform(purpose)
+        LlmLogs::Batch.require_supported_adapter!
         models = LlmLogs::BatchRequest.pending.where(purpose: purpose).distinct.pluck(:model)
         models.each { |model| LlmLogs::Batch.submit_pending(purpose: purpose, model: model) }
       end

data/app/jobs/llm_logs/batch/poll_job.rb

@@ -9,6 +9,7 @@ module LlmLogs
       STALE_CLAIM_AFTER = 15.minutes
 
       def perform
+        LlmLogs::Batch.require_supported_adapter!
         recover_stale_claims
         LlmLogs::Batch.unreconciled.where.not(provider_batch_id: nil).find_each do |batch|
           batch.reconcile!

data/app/models/llm_logs/batch/reconciler.rb

@@ -9,6 +9,7 @@ module LlmLogs
       end
 
       def call
+        LlmLogs::Batch.require_supported_adapter!
         adapter = LlmLogs::Batch.adapter_for(@batch.provider)
         status = adapter.terminal_status(@batch)
         case status

data/app/models/llm_logs/batch/submitter.rb

@@ -1,12 +1,13 @@
 module LlmLogs
   class Batch
-    # Groups pending BatchRequests of one purpose+model into a single OpenAI batch via
-    # ruby_llm-responses_api. To prevent two concurrent FlushJobs from double-submitting
-    # the same requests, it first CLAIMS the pending rows in a `FOR UPDATE SKIP LOCKED`
-    # transaction (assigning them to a placeholder Batch with no openai_batch_id, which
-    # flips them out of the `pending` scope and which PollJob ignores). It then submits to
-    # OpenAI and records the batch id. If submission fails, the claim is released (requests
-    # return to `pending`) and the placeholder batch is dropped, so the work retries next flush.
+    # Groups pending BatchRequests of one purpose+model into a single provider batch (Bedrock).
+    # To keep two concurrent FlushJobs from double-submitting the same requests, it first
+    # CLAIMS the pending rows in a `FOR UPDATE SKIP LOCKED` transaction, assigning them to a
+    # placeholder Batch with no provider batch id (stored in the legacy `openai_batch_id`
+    # column), which flips them out of the `pending` scope and which PollJob ignores. It then
+    # submits the batch and records its id. If submission fails, the claim is released
+    # (requests return to `pending`) and the placeholder batch is dropped, so the work retries
+    # on the next flush.
     class Submitter
       def initialize(purpose:, model:, metadata: {})
         @purpose = purpose
@@ -15,6 +16,7 @@ module LlmLogs
       end
 
       def call
+        LlmLogs::Batch.require_supported_adapter!
         batch = claim_batch
         return nil if batch.nil?
 

data/app/models/llm_logs/batch/trace_recorder.rb

@@ -27,23 +27,35 @@ module LlmLogs
             output: { "content" => span.serialize_content(message.content) },
             input_tokens: message.input_tokens,
             output_tokens: message.output_tokens,
-            cost: compute_cost(message)
+            cost: compute_cost(message, request: request, provider: provider)
           )
           span.finish
         end
         trace
       end
 
-      def compute_cost(message)
-        model_info = RubyLLM.models.find(message.model_id)
-        return nil unless model_info&.input_price_per_million && model_info&.output_price_per_million
+      # Prices the request at the submitted model's standard rates for this provider (the
+      # Bedrock id, e.g. us.anthropic.claude-haiku-4-5-...), falling back to the id the result
+      # reports (a native Anthropic id resolves to the anthropic provider's rates). nil when
+      # neither is in the registry or the registry has no price for the tokens used.
+      def compute_cost(message, request:, provider:)
+        model = pricing_model(request.model, provider) || pricing_model(message.model_id, nil)
+        return nil unless model
 
-        raw = (message.input_tokens.to_f * model_info.input_price_per_million +
-               message.output_tokens.to_f * model_info.output_price_per_million) / 1_000_000
-        (raw * BATCH_COST_MULTIPLIER).round(6)
+        tokens = RubyLLM::Tokens.new(input: message.input_tokens.to_i, output: message.output_tokens.to_i)
+        total = model.cost_for(tokens).total
+        total && (total * BATCH_COST_MULTIPLIER).round(6)
       rescue StandardError
         nil
       end
+
+      def pricing_model(model_id, provider)
+        return nil if model_id.blank?
+
+        provider.present? ? RubyLLM.models.find(model_id, provider: provider) : RubyLLM.models.find(model_id)
+      rescue RubyLLM::ModelNotFoundError
+        nil
+      end
     end
   end
 end

data/app/models/llm_logs/batch.rb

@@ -1,5 +1,15 @@
 module LlmLogs
   class Batch < ApplicationRecord
+    class UnsupportedAdapter < StandardError; end
+
+    def self.supported_adapter?
+      connection.adapter_name == "PostgreSQL"
+    end
+
+    def self.require_supported_adapter!
+      raise UnsupportedAdapter, "Provider batch execution requires PostgreSQL" unless supported_adapter?
+    end
+
     self.table_name = "llm_logs_batches"
 
     has_many :requests, class_name: "LlmLogs::BatchRequest", dependent: :destroy
@@ -19,6 +29,7 @@ module LlmLogs
     scope :unreconciled, -> { where.not(status: %i[reconciled failed expired]) }
 
     def self.enqueue(purpose:, model:, input:, instructions:, schema:, routing:, temperature: nil, reasoning_effort: nil)
+      require_supported_adapter!
       BatchRequest.create!(
         purpose: purpose,
         model: model,
@@ -50,19 +61,15 @@ module LlmLogs
     end
 
     def self.batchable?(model)
-      return false unless LlmLogs.batch_enabled?
+      return false unless supported_adapter? && LlmLogs.batch_enabled?
 
       !batch_provider_for(model).nil?
     end
 
-    # Which batch provider (if any) serves this model. Bedrock wins for Claude models when
-    # the Bedrock adapter is configured; otherwise fall back to the OpenAI provider when the
-    # model resolves there; otherwise nil (run synchronously).
+    # Which batch provider (if any) serves this model: :bedrock when the Bedrock adapter is
+    # registered and its model_matcher matches, otherwise nil (run synchronously).
     def self.batch_provider_for(model)
-      return :bedrock if bedrock_serves?(model)
-      return :openai_responses if openai_serves?(model)
-
-      nil
+      bedrock_serves?(model) ? :bedrock : nil
     end
 
     # The Bedrock minimum records-per-job floor for this model (0 when Bedrock does not serve it).
@@ -78,25 +85,5 @@ module LlmLogs
       matcher = config.model_matcher
       matcher.respond_to?(:call) ? matcher.call(model.to_s) : matcher.match?(model.to_s)
     end
-
-    def self.openai_serves?(model)
-      return false unless defined?(RubyLLM::Providers::OpenAIResponses)
-
-      servable_by_batch_provider?(model)
-    end
-
-    # The batch path submits via RubyLLM.batch(provider: batch_provider). A model is
-    # only batchable if that provider can actually serve it -- i.e. the model resolves
-    # under batch_provider. Models that belong to a different provider (e.g. Bedrock /
-    # Anthropic) don't resolve there, so they return false and the caller runs them
-    # synchronously instead of enqueueing work that would fail at submit time.
-    def self.servable_by_batch_provider?(model)
-      RubyLLM::Models.resolve(
-        model, provider: LlmLogs.batch_provider, assume_exists: false, config: RubyLLM.config
-      )
-      true
-    rescue RubyLLM::ModelNotFoundError
-      false
-    end
   end
 end

data/app/models/llm_logs/prompt.rb

@@ -5,8 +5,17 @@ module LlmLogs
     validates :slug, presence: true, uniqueness: true
     validates :name, presence: true
 
-    scope :with_tag,      ->(tag)  { where("? = ANY(tags)", tag) }
-    scope :with_any_tag,  ->(tags) { where("tags && ARRAY[?]::varchar[]", Array(tags)) }
+    scope :with_tag, ->(tag) { with_any_tag([tag]) }
+    scope :with_any_tag, ->(tags) {
+      values = Array(tags)
+      if values.empty?
+        none
+      elsif connection.adapter_name == "PostgreSQL"
+        where("tags && ARRAY[?]::varchar[]", values)
+      else
+        where("EXISTS (SELECT 1 FROM json_each(llm_logs_prompts.tags) AS tag WHERE tag.value COLLATE BINARY IN (?))", values)
+      end
+    }
 
     def tags_string
       Array(tags).join(", ")

data/app/models/llm_logs/span.rb

@@ -19,11 +19,23 @@ module LlmLogs
       LlmLogs::Tracer.current_span = parent_span
     end
 
+    # +message+ is a RubyLLM 2.x Message (or anything with +content+ and +tokens+).
     def record_response(message)
       self.output = { content: serialize_content(message.content) }
-      self.input_tokens = message.input_tokens
-      self.output_tokens = message.output_tokens
-      self.cached_tokens = message.cached_tokens
+      record_tokens(message.tokens)
+    end
+
+    # Copies a RubyLLM::Tokens onto the span. +input+ is non-cached input (RubyLLM 2.x no
+    # longer subtracts cache buckets from it); cache writes and thinking have no column and
+    # go to metadata.
+    def record_tokens(tokens)
+      return unless tokens
+
+      self.input_tokens = tokens.input
+      self.output_tokens = tokens.output
+      self.cached_tokens = tokens.cache_read
+      set_attribute("cache_write_tokens", tokens.cache_write) unless tokens.cache_write.nil?
+      set_attribute("thinking_tokens", tokens.thinking) unless tokens.thinking.nil?
     end
 
     # Structured (schema) responses arrive as a Hash/Array; keep them as-is so the

data/app/views/llm_logs/spans/show.html.erb

@@ -24,15 +24,15 @@
   </div>
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Input Tokens</dt>
-    <dd class="text-lg font-semibold text-gray-900 mt-1"><%= number_with_delimiter(@span.input_tokens || 0) %></dd>
+    <dd class="text-lg font-semibold text-gray-900 mt-1"><%= @span.input_tokens.nil? ? "Unavailable" : number_with_delimiter(@span.input_tokens) %></dd>
   </div>
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Output Tokens</dt>
-    <dd class="text-lg font-semibold text-gray-900 mt-1"><%= number_with_delimiter(@span.output_tokens || 0) %></dd>
+    <dd class="text-lg font-semibold text-gray-900 mt-1"><%= @span.output_tokens.nil? ? "Unavailable" : number_with_delimiter(@span.output_tokens) %></dd>
   </div>
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Cached Tokens</dt>
-    <dd class="text-lg font-semibold text-green-600 mt-1"><%= number_with_delimiter(@span.cached_tokens || 0) %></dd>
+    <dd class="text-lg font-semibold text-green-600 mt-1"><%= @span.cached_tokens.nil? ? "Unavailable" : number_with_delimiter(@span.cached_tokens) %></dd>
     <% if (@span.input_tokens || 0) > 0 && (@span.cached_tokens || 0) > 0 %>
       <dd class="text-xs text-green-600 mt-0.5"><%= (@span.cached_tokens.to_f / @span.input_tokens * 100).round %>% of input</dd>
     <% end %>

data/app/views/llm_logs/traces/index.html.erb

@@ -50,13 +50,13 @@
           </td>
           <td class="px-4 py-3 text-sm text-gray-500 text-right"><%= trace.spans_count %></td>
           <td class="px-4 py-3 text-sm text-gray-500 text-right">
-            <%= number_with_delimiter(trace.total_input_tokens) %> &rarr; <%= number_with_delimiter(trace.total_output_tokens) %>
+            <%= trace.metadata&.dig("usage_missing") ? "Usage unavailable" : number_with_delimiter(trace.total_input_tokens) %> &rarr; <%= trace.metadata&.dig("usage_missing") ? "Usage unavailable" : number_with_delimiter(trace.total_output_tokens) %>
             <% if trace.total_cached_tokens > 0 %>
-              <br><span class="text-xs text-green-600"><%= number_with_delimiter(trace.total_cached_tokens) %> cached</span>
+              <br><span class="text-xs text-green-600"><%= trace.metadata&.dig("usage_missing") ? "Usage unavailable" : number_with_delimiter(trace.total_cached_tokens) %> cached</span>
             <% end %>
           </td>
           <td class="px-4 py-3 text-sm text-gray-500 text-right">
-            <% if trace.total_cost > 0 %>$<%= sprintf('%.4f', trace.total_cost) %><% end %>
+            <% if trace.metadata&.dig('billing_mode') == 'subscription' %>Subscription · cost unavailable<% elsif trace.total_cost > 0 %>$<%= sprintf('%.4f', trace.total_cost) %><% end %>
           </td>
           <td class="px-4 py-3 text-sm text-gray-500 text-right">
             <%= format_duration_ms(trace.duration_ms) %>

data/app/views/llm_logs/traces/show.html.erb

@@ -23,6 +23,8 @@
   </div>
 </div>
 
+<% if @trace.metadata&.dig("billing_mode") == "subscription" %><p class="text-sm text-gray-500 mb-4">Subscription · cost unavailable</p><% end %>
+
 <div class="grid grid-cols-6 gap-4 mb-6">
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Model</dt>
@@ -34,15 +36,15 @@
   </div>
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Input Tokens</dt>
-    <dd class="text-2xl font-semibold text-gray-900 mt-1"><%= number_with_delimiter(@trace.total_input_tokens) %></dd>
+    <dd class="text-2xl font-semibold text-gray-900 mt-1"><%= @trace.metadata&.dig("usage_missing") ? "Usage unavailable" : number_with_delimiter(@trace.total_input_tokens) %></dd>
   </div>
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Output Tokens</dt>
-    <dd class="text-2xl font-semibold text-gray-900 mt-1"><%= number_with_delimiter(@trace.total_output_tokens) %></dd>
+    <dd class="text-2xl font-semibold text-gray-900 mt-1"><%= @trace.metadata&.dig("usage_missing") ? "Usage unavailable" : number_with_delimiter(@trace.total_output_tokens) %></dd>
   </div>
   <div class="bg-white rounded-lg p-4 shadow-sm ring-1 ring-gray-900/5">
     <dt class="text-xs font-medium text-gray-500 uppercase">Cached Tokens</dt>
-    <dd class="text-2xl font-semibold text-green-600 mt-1"><%= number_with_delimiter(@trace.total_cached_tokens) %></dd>
+    <dd class="text-2xl font-semibold text-green-600 mt-1"><%= @trace.metadata&.dig("usage_missing") ? "Usage unavailable" : number_with_delimiter(@trace.total_cached_tokens) %></dd>
     <% if @trace.total_input_tokens > 0 && @trace.total_cached_tokens > 0 %>
       <dd class="text-xs text-green-600 mt-0.5"><%= (@trace.total_cached_tokens.to_f / @trace.total_input_tokens * 100).round %>% of input</dd>
     <% end %>

data/db/migrate/001_create_llm_logs_traces.rb

@@ -3,7 +3,7 @@ class CreateLlmLogsTraces < ActiveRecord::Migration[8.0]
     create_table :llm_logs_traces do |t|
       t.string :name, null: false
       t.string :status, null: false, default: "running"
-      t.jsonb :metadata, default: {}
+      t.column :metadata, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), default: {}
       t.integer :total_input_tokens, default: 0
       t.integer :total_output_tokens, default: 0
       t.integer :total_cached_tokens, default: 0, null: false

data/db/migrate/002_create_llm_logs_spans.rb

@@ -7,8 +7,8 @@ class CreateLlmLogsSpans < ActiveRecord::Migration[8.0]
       t.string :span_type, null: false
       t.string :model
       t.string :provider
-      t.jsonb :input
-      t.jsonb :output
+      t.column :input, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json)
+      t.column :output, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json)
       t.integer :input_tokens
       t.integer :output_tokens
       t.integer :cached_tokens
@@ -16,7 +16,7 @@ class CreateLlmLogsSpans < ActiveRecord::Migration[8.0]
       t.float :duration_ms
       t.string :status, null: false, default: "ok"
       t.text :error_message
-      t.jsonb :metadata, default: {}
+      t.column :metadata, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), default: {}
       t.datetime :started_at, null: false
       t.datetime :completed_at
 

data/db/migrate/004_create_llm_logs_prompt_versions.rb

@@ -3,10 +3,10 @@ class CreateLlmLogsPromptVersions < ActiveRecord::Migration[8.0]
     create_table :llm_logs_prompt_versions do |t|
       t.references :prompt, null: false, foreign_key: { to_table: :llm_logs_prompts }
       t.integer :version_number, null: false
-      t.jsonb :messages, null: false, default: []
+      t.column :messages, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), null: false, default: []
       t.string :model
-      t.jsonb :model_params, default: {}
-      t.jsonb :default_variables, default: {}
+      t.column :model_params, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), default: {}
+      t.column :default_variables, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), default: {}
       t.text :changelog
 
       t.timestamps

data/db/migrate/006_add_tags_to_prompts.rb

@@ -1,6 +1,10 @@
 class AddTagsToPrompts < ActiveRecord::Migration[8.0]
   def change
-    add_column :llm_logs_prompts, :tags, :string, array: true, default: [], null: false
-    add_index :llm_logs_prompts, :tags, using: :gin, name: "index_llm_logs_prompts_on_tags"
+    if connection.adapter_name == "PostgreSQL"
+      add_column :llm_logs_prompts, :tags, :string, array: true, default: [], null: false
+      add_index :llm_logs_prompts, :tags, using: :gin, name: "index_llm_logs_prompts_on_tags"
+    else
+      add_column :llm_logs_prompts, :tags, :json, default: [], null: false
+    end
   end
 end

data/db/migrate/007_create_llm_logs_batches.rb

@@ -9,7 +9,7 @@ class CreateLlmLogsBatches < ActiveRecord::Migration[8.0]
       t.string :openai_error_file_id
       t.string :status, null: false, default: "pending"
       t.integer :request_count, null: false, default: 0
-      t.jsonb :metadata, null: false, default: {}
+      t.column :metadata, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), null: false, default: {}
       t.datetime :submitted_at
       t.datetime :completed_at
       t.datetime :reconciled_at

data/db/migrate/008_create_llm_logs_batch_requests.rb

@@ -6,8 +6,8 @@ class CreateLlmLogsBatchRequests < ActiveRecord::Migration[8.0]
       t.string :purpose, null: false
       t.string :status, null: false, default: "pending"
       t.string :model, null: false
-      t.jsonb :payload, null: false, default: {}
-      t.jsonb :routing, null: false, default: {}
+      t.column :payload, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), null: false, default: {}
+      t.column :routing, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), null: false, default: {}
       t.text :result_content
       t.integer :input_tokens
       t.integer :output_tokens

data/db/migrate/009_add_provider_columns_to_llm_logs_batches.rb

@@ -1,7 +1,7 @@
 class AddProviderColumnsToLlmLogsBatches < ActiveRecord::Migration[8.0]
   def change
     add_column :llm_logs_batches, :provider_batch_id, :string
-    add_column :llm_logs_batches, :provider_metadata, :jsonb, null: false, default: {}
+    add_column :llm_logs_batches, :provider_metadata, (connection.adapter_name == "PostgreSQL" ? :jsonb : :json), null: false, default: {}
     add_index  :llm_logs_batches, :provider_batch_id
 
     # Backfill existing OpenAI rows so the reconciler/poll job can key off the

data/lib/llm_logs/configuration.rb

@@ -3,7 +3,7 @@ module LlmLogs
     BedrockBatch = Struct.new(:role_arn, :s3_bucket, :s3_prefix, :min_records, :model_matcher, :region, keyword_init: true)
 
     attr_accessor :enabled, :auto_instrument, :retention_days, :prompts_source_path, :prompt_subfolders,
-                  :batch_enabled, :batch_provider, :page_size, :bedrock_batch, :reasoning_effort_options
+                  :batch_enabled, :page_size, :bedrock_batch, :reasoning_effort_options
 
     def initialize
       @enabled             = true
@@ -12,7 +12,6 @@ module LlmLogs
       @prompts_source_path = nil
       @prompt_subfolders   = %w[skills fragments templates]
       @batch_enabled       = true
-      @batch_provider      = :openai_responses
       @page_size           = 50
       @bedrock_batch       = nil
       # Effort tiers offered in the prompt form. Union of what current providers

data/lib/llm_logs/engine.rb

@@ -6,11 +6,20 @@ module LlmLogs
       ActiveSupport.on_load(:active_record) do
         if LlmLogs.auto_instrument && defined?(RubyLLM::Chat)
           require "llm_logs/instrumentation/ruby_llm_chat"
-          RubyLLM::Chat.prepend(LlmLogs::Instrumentation::RubyLlmChat)
+          LlmLogs::Instrumentation::RubyLlmChat.install!
         end
       end
     end
 
+    # Bedrock fixes missing from upstream ruby_llm 2.0.0. Installed whether or not
+    # auto-instrumentation is on: they change request behaviour, not logging.
+    initializer "llm_logs.ruby_llm_patches" do
+      if defined?(RubyLLM::VERSION)
+        require "llm_logs/ruby_llm_patches"
+        LlmLogs::RubyLLMPatches.install!
+      end
+    end
+
     rake_tasks do
       load File.expand_path("../tasks/llm_logs.rake", __dir__)
     end