llm_cost_tracker 0.8.0 → 0.10.0

data/lib/llm_cost_tracker/integrations/ruby_llm.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../providers/anthropic/tier_classification"
 
 module LlmCostTracker
   module Integrations
@@ -25,7 +26,7 @@ module LlmCostTracker
             patch_target(
               "RubyLLM::Provider",
               with: ProviderPatch,
-              methods: %i[slug complete embed transcribe]
+              methods: %i[slug complete embed transcribe paint moderate]
             )
           ]
         end
@@ -65,6 +66,69 @@ module LlmCostTracker
           )
         end
 
+        def record_image(provider, response, request:, latency_ms:)
+          usage = object_value(response, :usage)
+          usage = {} unless usage.is_a?(Hash)
+          raw_input = (usage[:input_tokens] || usage["input_tokens"]).to_i
+          raw_output = (usage[:output_tokens] || usage["output_tokens"]).to_i
+          image_input = image_token_detail(usage, :input)
+          image_output = image_token_detail(usage, :output)
+          text_input = [raw_input - image_input, 0].max
+          text_output = [raw_output - image_output, 0].max
+          record_passthrough(
+            provider: provider_slug(provider),
+            model: response_model_id(response) || model_id(request[:model]),
+            response: response,
+            latency_ms: latency_ms,
+            input_tokens: text_input,
+            image_input_tokens: image_input,
+            output_tokens: text_output,
+            image_output_tokens: image_output
+          )
+        end
+
+        def record_moderation(provider, response, request:, latency_ms:)
+          record_passthrough(
+            provider: provider_slug(provider),
+            model: response_model_id(response) || model_id(request[:model]),
+            response: response,
+            latency_ms: latency_ms,
+            input_tokens: 0,
+            output_tokens: 0
+          )
+        end
+
+        def image_token_detail(usage, direction)
+          container_key = direction == :input ? :input_tokens_details : :output_tokens_details
+          details = usage[container_key] || usage[container_key.to_s] || {}
+          return 0 unless details.is_a?(Hash)
+
+          (details[:image_tokens] || details["image_tokens"]).to_i
+        end
+
+        def record_passthrough(provider:, model:, response:, latency_ms:, input_tokens:, output_tokens:,
+                               image_input_tokens: 0, image_output_tokens: 0)
+          return unless active?
+
+          record_safely do
+            LlmCostTracker::Tracker.record(
+              event: Event.build(
+                provider: provider,
+                model: model,
+                token_usage: TokenUsage.build(
+                  input_tokens: input_tokens,
+                  output_tokens: output_tokens,
+                  image_input_tokens: image_input_tokens,
+                  image_output_tokens: image_output_tokens
+                ),
+                usage_source: :sdk_response,
+                provider_response_id: provider_response_id(response)
+              ),
+              latency_ms: latency_ms
+            )
+          end
+        end
+
         def record_usage(provider:, model:, response:, latency_ms:, stream:, output_tokens: nil)
           return unless active?
 
@@ -77,10 +141,10 @@ module LlmCostTracker
             hidden_output = object_value(response, :thinking_tokens, :reasoning_tokens).to_i
 
             LlmCostTracker::Tracker.record(
-              capture: UsageCapture.build(
+              event: Event.build(
                 provider: provider,
                 model: model,
-                pricing_mode: pricing_mode(response),
+                pricing_mode: pricing_mode(provider: provider, response: response),
                 token_usage: TokenUsage.build(
                   input_tokens: regular_input_tokens(input_tokens, cache_read),
                   output_tokens: output_tokens.to_i,
@@ -119,13 +183,16 @@ module LlmCostTracker
         end
 
         def provider_response_id(response)
-          object_value(response, :id, :provider_response_id) || object_dig(response, :raw, :id)
+          object_value(response, :id, :provider_response_id)
         end
 
-        def pricing_mode(response)
-          object_value(response, :pricing_mode, :service_tier) ||
-            object_dig(response, :raw, :pricing_mode) ||
-            object_dig(response, :raw, :service_tier)
+        def pricing_mode(provider:, response:)
+          raw = object_value(response, :pricing_mode, :service_tier)
+          if provider == "anthropic" && LlmCostTracker::Providers::Anthropic::TierClassification.standard_equivalent_tier?(raw)
+            return nil
+          end
+
+          raw
         end
       end
 
@@ -133,14 +200,14 @@ module LlmCostTracker
         def complete(*args, **kwargs, &)
           integration = LlmCostTracker::Integrations::RubyLlm
           request = integration.request_params(args, kwargs)
-          integration.enforce_budget!
+          integration.enforce_budget!(request: request)
           started_at = LlmCostTracker::Timing.now_monotonic
           response = super
           integration.record_completion(
             self,
             response,
             request: request,
-            latency_ms: integration.elapsed_ms(started_at),
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
             stream: integration.streaming_request?(request, has_block: block_given?)
           )
           response
@@ -149,14 +216,14 @@ module LlmCostTracker
         def embed(*args, **kwargs)
           integration = LlmCostTracker::Integrations::RubyLlm
           request = integration.request_params(args, kwargs)
-          integration.enforce_budget!
+          integration.enforce_budget!(request: request)
           started_at = LlmCostTracker::Timing.now_monotonic
           response = super
           integration.record_embedding(
             self,
             response,
             request: request,
-            latency_ms: integration.elapsed_ms(started_at)
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
           )
           response
         end
@@ -164,14 +231,44 @@ module LlmCostTracker
         def transcribe(*args, **kwargs)
           integration = LlmCostTracker::Integrations::RubyLlm
           request = integration.request_params(args, kwargs)
-          integration.enforce_budget!
+          integration.enforce_budget!(request: request)
           started_at = LlmCostTracker::Timing.now_monotonic
           response = super
           integration.record_transcription(
             self,
             response,
             request: request,
-            latency_ms: integration.elapsed_ms(started_at)
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
+          )
+          response
+        end
+
+        def paint(*args, **kwargs)
+          integration = LlmCostTracker::Integrations::RubyLlm
+          request = integration.request_params(args, kwargs)
+          integration.enforce_budget!(request: request)
+          started_at = LlmCostTracker::Timing.now_monotonic
+          response = super
+          integration.record_image(
+            self,
+            response,
+            request: request,
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
+          )
+          response
+        end
+
+        def moderate(*args, **kwargs)
+          integration = LlmCostTracker::Integrations::RubyLlm
+          request = integration.request_params(args, kwargs)
+          integration.enforce_budget!(request: request)
+          started_at = LlmCostTracker::Timing.now_monotonic
+          response = super
+          integration.record_moderation(
+            self,
+            response,
+            request: request,
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
           )
           response
         end

data/lib/llm_cost_tracker/integrations.rb

@@ -1,26 +1,29 @@
 # frozen_string_literal: true
 
 require_relative "errors"
-require_relative "integrations/openai"
-require_relative "integrations/anthropic"
-require_relative "integrations/ruby_llm"
+require_relative "logging"
 
 module LlmCostTracker
   module Integrations
-    AVAILABLE = {
-      openai: Openai,
-      anthropic: Anthropic,
-      ruby_llm: RubyLlm
-    }.freeze
+    autoload :Base, "llm_cost_tracker/integrations/base"
+    autoload :Openai, "llm_cost_tracker/integrations/openai"
+    autoload :Anthropic, "llm_cost_tracker/integrations/anthropic"
+    autoload :RubyLlm, "llm_cost_tracker/integrations/ruby_llm"
+
+    INTEGRATION_CONSTANTS = { openai: :Openai, anthropic: :Anthropic, ruby_llm: :RubyLlm }.freeze
+    DOUBLE_INSTRUMENTATION_OVERLAPS = %i[openai anthropic].freeze
+    private_constant :DOUBLE_INSTRUMENTATION_OVERLAPS
 
     module_function
 
     def install!(names = LlmCostTracker.configuration.instrumented_integrations)
-      normalize(names).each { |name| fetch(name).install }
+      normalized = normalize(names)
+      warn_double_instrumentation(normalized)
+      normalized.each { |name| fetch(name).install }
     end
 
     def checks(names = LlmCostTracker.configuration.instrumented_integrations)
-      return [Base::Result.new(:integrations, :ok, "no SDK integrations enabled")] if names.empty?
+      return [Base::Result.new(:ok, "integrations", "no SDK integrations enabled")] if names.empty?
 
       normalize(names).map { |name| fetch(name).status }
     end
@@ -29,15 +32,31 @@ module LlmCostTracker
       Array(names).flatten.uniq
     end
 
+    def warn_double_instrumentation(names)
+      return unless names.include?(:ruby_llm)
+
+      overlapping = names & DOUBLE_INSTRUMENTATION_OVERLAPS
+      return if overlapping.empty?
+
+      Logging.warn(
+        ":ruby_llm is enabled together with #{overlapping.map(&:inspect).join(', ')}. " \
+        "RubyLLM uses HTTP underneath, so calls routed to those providers may be recorded twice " \
+        "(once via the SDK patch, once via the Faraday parser). Pick one path per provider."
+      )
+    end
+
     def fetch(name)
-      AVAILABLE.fetch(name) do
-        message = "Unknown integration: #{name.inspect}. Use one of: #{names.join(', ')}"
-        raise LlmCostTracker::Error, message
+      const_name = INTEGRATION_CONSTANTS[name.to_sym]
+      unless const_name
+        raise LlmCostTracker::Error,
+              "Unknown integration: #{name.inspect}. Use one of: #{names.join(', ')}"
       end
+
+      const_get(const_name)
     end
 
     def names
-      AVAILABLE.keys
+      INTEGRATION_CONSTANTS.keys
     end
   end
 end

data/lib/llm_cost_tracker/ledger/period/totals.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 require_relative "../period"
 
 module LlmCostTracker
@@ -26,28 +28,44 @@ module LlmCostTracker
         attr_reader :periods, :time
 
         def snapshot_totals
-          values = periods.to_h { |period| [period, 0.0] }
+          values = periods.to_h { |period| [period, BigDecimal("0")] }
           period_by_name = periods.to_h { |period| [period.name, period] }
           sql = periods.map { |period| snapshot_select(period) }.join(" UNION ALL ")
           LlmCostTracker::Call.find_by_sql(sql).each do |row|
             period = period_by_name.fetch(row.period_key)
-            values[period] = row.total_cost.to_f
+            values[period] = BigDecimal(row.total_cost.to_s)
           end
           values
         end
 
         def snapshot_select(period)
           start = Period.range_start(period, time)
+          components = [period_total_sql(period, start)]
+          components << pending_total_sql(start) if Ingestion.async?
           "SELECT #{connection.quote(period.name)} AS period_key, " \
-            "(#{rollup_total_sql(period)}) + (#{pending_total_sql(start)}) AS total_cost"
+            "(#{components.join(') + (')}) AS total_cost"
+        end
+
+        def period_total_sql(period, start)
+          if LlmCostTracker.configuration.cache_rollups
+            "GREATEST(COALESCE(#{rollup_sum_sql(period)}, 0), COALESCE(#{calls_sum_sql(start)}, 0))"
+          else
+            "COALESCE(#{calls_sum_sql(start)}, 0)"
+          end
         end
 
-        def rollup_total_sql(period)
+        def rollup_sum_sql(period)
           table = connection.quote_table_name("llm_cost_tracker_call_rollups")
-          "COALESCE((SELECT SUM(total_cost) FROM #{table} " \
+          "(SELECT SUM(total_cost) FROM #{table} " \
             "WHERE period = #{connection.quote(Period::PERIODS.fetch(period))} " \
-            "AND period_start = #{connection.quote(Period.bucket(period, time))} " \
-            "AND currency = #{connection.quote(Ledger::Rollups::DEFAULT_CURRENCY)}), 0)"
+            "AND period_start = #{connection.quote(Period.bucket(period, time))})"
+        end
+
+        def calls_sum_sql(start)
+          table = connection.quote_table_name("llm_cost_tracker_calls")
+          tracked_at = connection.quote_column_name("tracked_at")
+          "(SELECT SUM(total_cost) FROM #{table} " \
+            "WHERE #{tracked_at} BETWEEN #{connection.quote(start)} AND #{connection.quote(time)})"
         end
 
         def pending_total_sql(start)

data/lib/llm_cost_tracker/ledger/rollups.rb

@@ -34,23 +34,26 @@ module LlmCostTracker
         private
 
         def period_rows(event)
-          currency = currency_for(event)
+          currency = currency_from_snapshot(event.pricing_snapshot)
+          provider = event.provider.to_s
           Period::PERIODS.map do |period, name|
             {
               period: name,
               period_start: Period.bucket(period, event.tracked_at),
               currency: currency,
+              provider: provider,
               total_cost: event.total_cost
             }
           end
         end
 
         def period_rows_for_events(events)
-          call_rollups(events).map do |(period, period_start, currency), total_cost|
+          call_rollups(events).map do |(period, period_start, currency, provider), total_cost|
             {
               period: period,
               period_start: period_start,
               currency: currency,
+              provider: provider,
               total_cost: total_cost
             }
           end
@@ -58,30 +61,34 @@ module LlmCostTracker
 
         def call_rollups(events)
           events.each_with_object(Hash.new { |totals, key| totals[key] = BigDecimal("0") }) do |event, totals|
-            currency = currency_for(event)
+            currency = currency_from_snapshot(event.pricing_snapshot)
+            provider = event.provider.to_s
             Period::PERIODS.each do |period, name|
-              totals[[name, Period.bucket(period, event.tracked_at), currency]] += BigDecimal(event.total_cost.to_s)
+              key = [name, Period.bucket(period, event.tracked_at), currency, provider]
+              totals[key] += BigDecimal(event.total_cost.to_s)
             end
           end
         end
 
         def period_decrement_totals(call_rows)
           call_rows.each_with_object(Hash.new { |totals, key| totals[key] = BigDecimal("0") }) do |row, totals|
-            _id, tracked_at, total_cost, pricing_snapshot = row
+            _id, tracked_at, total_cost, pricing_snapshot, provider = row
             next unless total_cost
 
             currency = currency_from_snapshot(pricing_snapshot)
+            provider_key = provider.to_s
             Period::PERIODS.each_key do |period|
-              totals[[period, Period.bucket(period, tracked_at), currency]] += total_cost
+              totals[[period, Period.bucket(period, tracked_at), currency, provider_key]] += total_cost
             end
           end
         end
 
         def apply_decrements(totals)
           now = Time.now.utc
-          buckets_by_period = totals.each_with_object({}) do |((period, period_start, currency), amount), grouped|
-            grouped[[period, currency]] ||= {}
-            grouped[[period, currency]][period_start] = amount
+          buckets_by_period = totals.each_with_object({}) do |(key, amount), grouped|
+            period, period_start, currency, provider = key
+            grouped[[period, currency, provider]] ||= {}
+            grouped[[period, currency, provider]][period_start] = amount
           end
 
           conn = LlmCostTracker::CallRollup.connection
@@ -89,10 +96,11 @@ module LlmCostTracker
           period_col = conn.quote_column_name("period")
           start_col = conn.quote_column_name("period_start")
           currency_col = conn.quote_column_name("currency")
+          provider_col = conn.quote_column_name("provider")
           total_col = conn.quote_column_name("total_cost")
           updated_col = conn.quote_column_name("updated_at")
 
-          buckets_by_period.each do |(period, currency), by_start|
+          buckets_by_period.each do |(period, currency, provider), by_start|
             case_clauses = by_start.map do |period_start, amount|
               "WHEN #{start_col} = #{conn.quote(period_start)} THEN #{conn.quote(amount)}"
             end.join(" ")
@@ -104,18 +112,15 @@ module LlmCostTracker
               "#{updated_col} = #{conn.quote(now)} " \
               "WHERE #{period_col} = #{conn.quote(Period::PERIODS.fetch(period))} " \
               "AND #{currency_col} = #{conn.quote(currency)} " \
+              "AND #{provider_col} = #{conn.quote(provider)} " \
               "AND #{start_col} IN (#{starts})"
             )
           end
         end
 
-        def currency_for(event)
-          snapshot = event.respond_to?(:pricing_snapshot) ? event.pricing_snapshot : nil
-          currency_from_snapshot(snapshot)
-        end
-
         def currency_from_snapshot(snapshot)
-          (snapshot.is_a?(Hash) && (snapshot["currency"] || snapshot[:currency])) || DEFAULT_CURRENCY
+          value = (snapshot.is_a?(Hash) && (snapshot["currency"] || snapshot[:currency])) || DEFAULT_CURRENCY
+          value.to_s.upcase
         end
 
         def upsert_call_rollups(rows)
@@ -130,7 +135,7 @@ module LlmCostTracker
         def call_rollups_unique_by
           return unless LlmCostTracker::CallRollup.connection.supports_insert_conflict_target?
 
-          %i[period period_start currency]
+          %i[period period_start currency provider]
         end
       end
     end

data/lib/llm_cost_tracker/ledger/schema/call_line_items.rb

@@ -27,6 +27,11 @@ module LlmCostTracker
           provider_field
           provider_item_id
           details
+          created_at
+        ].freeze
+
+        REQUIRED_INDEX_COLUMNS = [
+          %w[llm_cost_tracker_call_id position]
         ].freeze
 
         class << self
@@ -37,11 +42,46 @@ module LlmCostTracker
             return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
 
             columns = LlmCostTracker::CallLineItem.columns_hash
+            cache = @schema_capabilities
+            return cache.fetch(:errors) if cache && cache.fetch(:columns).equal?(columns)
+
+            errors = compute_errors(connection, table_name, columns)
+            @schema_capabilities = { columns: columns, errors: errors }
+            errors
+          end
+
+          private
+
+          def compute_errors(connection, table_name, columns)
             errors = []
             missing = REQUIRED_COLUMNS - columns.keys
             errors << "missing columns: #{missing.join(', ')}" if missing.any?
             errors.concat(Adapter.json_column_errors(columns["details"], connection, "details"))
-            errors
+            errors.concat(missing_index_errors(connection, table_name))
+            errors << missing_fk_error(connection, table_name) if missing_fk?(connection, table_name)
+            errors.compact
+          end
+
+          def missing_index_errors(connection, table_name)
+            existing = connection.indexes(table_name).map { |index| Array(index.columns).map(&:to_s) }
+            REQUIRED_INDEX_COLUMNS.filter_map do |required|
+              next if existing.any? { |columns| columns == required }
+
+              "missing index on (#{required.join(', ')})"
+            end
+          end
+
+          def missing_fk?(connection, table_name)
+            connection.foreign_keys(table_name).none? do |fk|
+              fk.column.to_s == "llm_cost_tracker_call_id" &&
+                fk.to_table.to_s == "llm_cost_tracker_calls"
+            end
+          rescue NotImplementedError, NoMethodError
+            false
+          end
+
+          def missing_fk_error(_connection, _table_name)
+            "missing foreign key on llm_cost_tracker_call_id referencing llm_cost_tracker_calls"
           end
         end
       end

data/lib/llm_cost_tracker/ledger/schema/call_rollups.rb

@@ -6,8 +6,8 @@ module LlmCostTracker
   module Ledger
     module Schema
       module CallRollups
-        REQUIRED_COLUMNS = %w[period period_start currency total_cost].freeze
-        UNIQUE_COLUMNS = %i[period period_start currency].freeze
+        REQUIRED_COLUMNS = %w[period period_start currency provider total_cost created_at updated_at].freeze
+        UNIQUE_COLUMNS = %i[period period_start currency provider].freeze
 
         class << self
           def current_schema_errors
@@ -16,17 +16,27 @@ module LlmCostTracker
             table_name = LlmCostTracker::CallRollup.table_name
             return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
 
+            columns = LlmCostTracker::CallRollup.columns_hash
+            cache = @schema_capabilities
+            return cache.fetch(:errors) if cache && cache.fetch(:columns).equal?(columns)
+
+            errors = compute_errors(connection, table_name, columns)
+            @schema_capabilities = { columns: columns, errors: errors }
+            errors
+          end
+
+          private
+
+          def compute_errors(connection, table_name, columns)
             errors = []
-            missing = REQUIRED_COLUMNS - LlmCostTracker::CallRollup.columns_hash.keys
+            missing = REQUIRED_COLUMNS - columns.keys
             errors << "missing columns: #{missing.join(', ')}" if missing.any?
             unless unique_period_index?(connection, table_name)
-              errors << "missing unique index: period, period_start, currency"
+              errors << "missing unique index: period, period_start, currency, provider"
             end
             errors
           end
 
-          private
-
           def unique_period_index?(connection, table_name)
             connection.index_exists?(table_name, UNIQUE_COLUMNS, unique: true)
           end

data/lib/llm_cost_tracker/ledger/schema/call_tags.rb

@@ -6,6 +6,11 @@ module LlmCostTracker
       module CallTags
         REQUIRED_COLUMNS = %w[llm_cost_tracker_call_id key value].freeze
 
+        REQUIRED_INDEX_COLUMNS = [
+          %w[key value],
+          %w[llm_cost_tracker_call_id]
+        ].freeze
+
         class << self
           def current_schema_errors
             connection = LlmCostTracker::Call.connection
@@ -14,10 +19,31 @@ module LlmCostTracker
             return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
 
             columns = LlmCostTracker::CallTag.columns_hash
+            cache = @schema_capabilities
+            return cache.fetch(:errors) if cache && cache.fetch(:columns).equal?(columns)
+
+            errors = compute_errors(connection, table_name, columns)
+            @schema_capabilities = { columns: columns, errors: errors }
+            errors
+          end
+
+          private
+
+          def compute_errors(connection, table_name, columns)
+            errors = []
             missing = REQUIRED_COLUMNS - columns.keys
-            return [] if missing.empty?
+            errors << "missing columns: #{missing.join(', ')}" if missing.any?
+            errors.concat(missing_index_errors(connection, table_name))
+            errors
+          end
+
+          def missing_index_errors(connection, table_name)
+            existing = connection.indexes(table_name).map { |index| Array(index.columns).map(&:to_s) }
+            REQUIRED_INDEX_COLUMNS.filter_map do |required|
+              next if existing.any? { |columns| (required - columns).empty? }
 
-            ["missing columns: #{missing.join(', ')}"]
+              "missing index on (#{required.join(', ')})"
+            end
           end
         end
       end

data/lib/llm_cost_tracker/ledger/schema/calls.rb

@@ -18,6 +18,8 @@ module LlmCostTracker
           cache_write_extended_input_tokens
           audio_input_tokens
           audio_output_tokens
+          image_input_tokens
+          image_output_tokens
           hidden_output_tokens
           total_cost
           latency_ms
@@ -45,10 +47,6 @@ module LlmCostTracker
         private_constant :REQUIRED_INDEXES
 
         class << self
-          def current_schema?
-            current_schema_errors.empty?
-          end
-
           def current_schema_errors
             schema_capabilities.fetch(:current_schema_errors)
           end

data/lib/llm_cost_tracker/ledger/schema/ingestion_inbox_entries.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+
+module LlmCostTracker
+  module Ledger
+    module Schema
+      module IngestionInboxEntries
+        REQUIRED_COLUMNS = %w[
+          event_id
+          total_cost
+          tracked_at
+          payload
+          locked_at
+          locked_by
+          attempts
+          last_error
+          created_at
+          updated_at
+        ].freeze
+
+        UNIQUE_COLUMNS = %i[event_id].freeze
+
+        class << self
+          def current_schema_errors
+            connection = LlmCostTracker::Ingestion::InboxEntry.connection
+            Adapter.ensure_supported!(connection)
+            table_name = LlmCostTracker::Ingestion::InboxEntry.table_name
+            return ["#{table_name} table is missing"] unless connection.data_source_exists?(table_name)
+
+            columns = LlmCostTracker::Ingestion::InboxEntry.columns_hash
+            cache = @schema_capabilities
+            return cache.fetch(:errors) if cache && cache.fetch(:columns).equal?(columns)
+
+            errors = compute_errors(connection, table_name, columns)
+            @schema_capabilities = { columns: columns, errors: errors }
+            errors
+          end
+
+          private
+
+          def compute_errors(connection, table_name, columns)
+            errors = []
+            missing = REQUIRED_COLUMNS - columns.keys
+            errors << "missing columns: #{missing.join(', ')}" if missing.any?
+            errors << "missing unique index: event_id" unless event_id_unique_index?(connection, table_name)
+            errors
+          end
+
+          def event_id_unique_index?(connection, table_name)
+            connection.index_exists?(table_name, UNIQUE_COLUMNS, unique: true)
+          end
+        end
+      end
+    end
+  end
+end