llm_cost_tracker 0.9.0 → 0.11.0

data/lib/llm_cost_tracker/reconciliation/diff.rb

@@ -28,7 +28,7 @@ module LlmCostTracker
         @provider = provider.to_s
         @period_start = parse_date(period_start)
         @period_end = parse_date(period_end)
-        @scope = symbolize(scope || {}).slice(*SCOPE_KEYS)
+        @scope = (scope || {}).to_h.transform_keys { |key| key.to_s.to_sym }.slice(*SCOPE_KEYS)
         @currency = (currency || Ledger::Rollups::DEFAULT_CURRENCY).to_s.upcase
         @drilldown_limit = drilldown_limit
         raise ArgumentError, "source must be present" if @source.empty?
@@ -37,7 +37,7 @@ module LlmCostTracker
       end
 
       def call
-        provider_total = scoped_invoices_relation_for(:cost, fully_contained: true)
+        provider_total = scoped_cost_invoices_in_window
                          .sum(:billed_amount)
                          .then { |sum| BigDecimal(sum.to_s) }
         local_index = local_attribution_index_distinct
@@ -66,7 +66,7 @@ module LlmCostTracker
           unmatched_local_calls: cap_by_amount(unmatched_locals, :total_cost),
           unmatched_local_calls_total: unmatched_local_calls_total_count(invoice_basis_values),
           non_cost_rows: cap_by_amount(non_cost_rows, :billed_amount),
-          non_cost_rows_total: non_cost_invoices_total_count
+          non_cost_rows_total: scoped_non_cost_invoices_relation.count
         )
       end
 
@@ -88,10 +88,10 @@ module LlmCostTracker
         relation.to_a
       end
 
-      def scoped_invoices_relation_for(row_type_filter = nil, fully_contained: false)
+      def scoped_cost_invoices_in_window
         relation = scoped_invoices_relation
-        relation = relation.where(period_start: period_start..).where(period_end: ..period_end) if fully_contained
-        return relation unless row_type_filter == :cost
+                   .where(period_start: period_start..)
+                   .where(period_end: ..period_end)
 
         connection = ProviderInvoice.connection
         if Ledger::Schema::Adapter.postgresql?(connection)
@@ -187,10 +187,8 @@ module LlmCostTracker
 
       def unmatched_provider_rows_from_sql(local_index)
         rows = BASIS_DIMENSION.each_key.flat_map do |basis|
-          next [] if basis == PERIOD_ONLY_BASIS
-
           column = BASIS_DIMENSION[basis].to_s
-          relation = scoped_invoices_relation_for(:cost, fully_contained: true)
+          relation = scoped_cost_invoices_in_window
           relation = where_match_basis_eq(relation, basis)
           relation = where_metadata_present(relation, column)
           values = local_index[basis].to_a
@@ -213,10 +211,8 @@ module LlmCostTracker
 
       def unmatched_provider_rows_total_count(local_index)
         BASIS_DIMENSION.each_key.sum do |basis|
-          next 0 if basis == PERIOD_ONLY_BASIS
-
           column = BASIS_DIMENSION[basis].to_s
-          relation = scoped_invoices_relation_for(:cost, fully_contained: true)
+          relation = scoped_cost_invoices_in_window
           relation = where_match_basis_eq(relation, basis)
           relation = where_metadata_present(relation, column)
           values = local_index[basis].to_a
@@ -227,13 +223,9 @@ module LlmCostTracker
 
       def local_attribution_index_distinct
         BASIS_DIMENSION.each_key.to_h do |basis|
-          if basis == PERIOD_ONLY_BASIS
-            [basis, Set.new]
-          else
-            column = BASIS_DIMENSION[basis]
-            values = scoped_calls_relation.where.not(column => nil).distinct.pluck(column)
-            [basis, Set.new(values)]
-          end
+          column = BASIS_DIMENSION[basis]
+          values = scoped_calls_relation.where.not(column => nil).distinct.pluck(column)
+          [basis, Set.new(values)]
         end
       end
 
@@ -252,38 +244,31 @@ module LlmCostTracker
 
       def unmatched_local_calls_total_count(invoice_basis_values)
         unmatched = 0
-        scoped_calls_relation.find_each(batch_size: 1_000) do |call|
-          attribution = ATTRIBUTION_KEYS.each_with_object({}) do |key, acc|
-            value = call.public_send(key)
-            acc[key] = value unless value.nil? || value.to_s.empty?
+        scoped_calls_relation.in_batches(of: 1_000) do |batch|
+          batch.pluck(*ATTRIBUTION_KEYS).each do |row|
+            attribution = ATTRIBUTION_KEYS.zip(row).each_with_object({}) do |(key, value), acc|
+              acc[key] = value unless value.nil? || value.to_s.empty?
+            end
+            next if attribution.empty?
+            next if local_call_matched?(attribution, invoice_basis_values)
+
+            unmatched += 1
           end
-          next if attribution.empty?
-          next if local_call_matched?(attribution, invoice_basis_values)
-
-          unmatched += 1
         end
         unmatched
       end
 
       def invoice_basis_values_distinct_sql
         BASIS_DIMENSION.each_key.to_h do |basis|
-          if basis == PERIOD_ONLY_BASIS
-            [basis, Set.new]
-          else
-            column = BASIS_DIMENSION[basis].to_s
-            relation = scoped_invoices_relation_for(:cost, fully_contained: true)
-            relation = where_match_basis_eq(relation, basis)
-            relation = where_metadata_present(relation, column)
-            values = pluck_metadata_distinct(relation, column)
-            [basis, Set.new(values)]
-          end
+          column = BASIS_DIMENSION[basis].to_s
+          relation = scoped_cost_invoices_in_window
+          relation = where_match_basis_eq(relation, basis)
+          relation = where_metadata_present(relation, column)
+          values = pluck_metadata_distinct(relation, column)
+          [basis, Set.new(values)]
         end
       end
 
-      def non_cost_invoices_total_count
-        scoped_non_cost_invoices_relation.count
-      end
-
       def scoped_non_cost_invoices_relation
         connection = ProviderInvoice.connection
         if Ledger::Schema::Adapter.postgresql?(connection)
@@ -414,10 +399,6 @@ module LlmCostTracker
         ((local - provider) * 100 / provider).round(4).to_f
       end
 
-      def symbolize(hash)
-        hash.to_h.transform_keys { |key| key.to_s.to_sym }
-      end
-
       def parse_date(value)
         return value if value.is_a?(Date)
 

data/lib/llm_cost_tracker/reconciliation/diff_result.rb

@@ -39,10 +39,6 @@ module LlmCostTracker
 
         delta_percent.abs <= threshold_percent
       end
-
-      def empty?
-        provider_total.zero? && local_total.zero?
-      end
     end
   end
 end

data/lib/llm_cost_tracker/reconciliation/importer.rb

@@ -5,6 +5,7 @@ require "date"
 require "json"
 
 require_relative "import_result"
+require_relative "sources/coercion"
 require_relative "../ledger/rollups"
 
 module LlmCostTracker
@@ -81,6 +82,7 @@ module LlmCostTracker
 
         ProviderInvoiceImport.create!(
           source: source,
+          provider: provider,
           cursor: cursor,
           window_start: window&.first,
           window_end: window&.last,
@@ -119,7 +121,7 @@ module LlmCostTracker
       def normalize_rows(rows)
         errors = []
         normalized = rows.each_with_index.filter_map do |row, index|
-          attrs = symbolize(row)
+          attrs = Sources::Coercion.symbolize(row)
           missing = REQUIRED_FIELDS - attrs.keys
           if missing.any?
             errors << "row #{index}: missing #{missing.join(', ')}"
@@ -212,12 +214,6 @@ module LlmCostTracker
         raw.start_with?(prefix) ? raw : "#{prefix}#{raw}"
       end
 
-      def symbolize(row)
-        return row if row.is_a?(Hash) && row.keys.all?(Symbol)
-
-        row.to_h.transform_keys { |key| key.to_s.to_sym }
-      end
-
       def parse_date(value)
         return value if value.is_a?(Date)
 

data/lib/llm_cost_tracker/reconciliation/sources/anthropic_usage.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require "bigdecimal"
-require "json"
 require "time"
 
+require_relative "coercion"
 require_relative "fingerprint"
+require_relative "../../providers/anthropic/tier_classification"
 
 module LlmCostTracker
   module Reconciliation
@@ -18,13 +19,11 @@ module LlmCostTracker
         ROW_TYPE_COST = "cost"
         AUTHORITY_COST_API = "cost_api"
         DEFAULT_METER = "tokens"
-        DATA_RESIDENCY_GEOS = %w[us].freeze
-        private_constant :DATA_RESIDENCY_GEOS
 
         module_function
 
         def parse(response, authority: AUTHORITY_COST_API, row_type: ROW_TYPE_COST)
-          payload = coerce_hash(response)
+          payload = Coercion.coerce_hash(response, label: "Anthropic Usage")
           buckets = Array(payload[:data])
           buckets.flat_map do |bucket|
             rows_for_bucket(bucket, authority: authority, row_type: row_type)
@@ -32,7 +31,7 @@ module LlmCostTracker
         end
 
         def rows_for_bucket(bucket, authority:, row_type:)
-          bucket = symbolize(bucket)
+          bucket = Coercion.symbolize(bucket)
           starting_at = bucket[:starting_at]
           ending_at = bucket[:ending_at]
           return [] unless starting_at && ending_at
@@ -51,7 +50,7 @@ module LlmCostTracker
         end
 
         def row_for_result(raw, period_start:, period_end:, starting_at:, ending_at:, authority:, row_type:)
-          result = symbolize(raw)
+          result = Coercion.symbolize(raw)
           raw_amount = result[:amount]
           return nil if raw_amount.nil?
 
@@ -109,7 +108,9 @@ module LlmCostTracker
         def pricing_mode_for(result)
           modes = []
           modes << "batch" if result[:service_tier].to_s.downcase == "batch"
-          modes << "data_residency" if DATA_RESIDENCY_GEOS.include?(result[:inference_geo].to_s.downcase)
+          if LlmCostTracker::Providers::Anthropic::TierClassification.data_residency_geo?(result[:inference_geo])
+            modes << "data_residency"
+          end
           modes.empty? ? nil : modes.uniq.join("_")
         end
 
@@ -121,19 +122,11 @@ module LlmCostTracker
         end
 
         def fingerprint_for(result, starting_at:, ending_at:)
-          attributes = result.merge(starting_at: normalized_epoch(starting_at),
-                                    ending_at: normalized_epoch(ending_at))
+          attributes = result.merge(starting_at: Coercion.normalized_epoch(starting_at),
+                                    ending_at: Coercion.normalized_epoch(ending_at))
           Fingerprint.compute(FINGERPRINT_KEYS, attributes)
         end
 
-        def normalized_epoch(value)
-          return value.to_i if value.is_a?(Numeric)
-
-          Time.parse(value.to_s).utc.to_i
-        rescue ArgumentError
-          value.to_s
-        end
-
         def parse_date(value)
           return value if value.is_a?(Date)
           return Time.at(value).utc.to_date if value.is_a?(Numeric)
@@ -149,22 +142,6 @@ module LlmCostTracker
                  end
           (time - 1).utc.to_date
         end
-
-        def coerce_hash(response)
-          return {} if response.nil?
-          return symbolize(response) if response.is_a?(Hash)
-
-          parsed = JSON.parse(response.to_s)
-          raise ArgumentError, "Anthropic Usage payload must be a JSON object" unless parsed.is_a?(Hash)
-
-          symbolize(parsed)
-        rescue JSON::ParserError => e
-          raise ArgumentError, "Unable to parse Anthropic Usage payload: #{e.message}"
-        end
-
-        def symbolize(hash)
-          hash.to_h.transform_keys { |key| key.to_s.to_sym }
-        end
       end
     end
   end

data/lib/llm_cost_tracker/reconciliation/sources/coercion.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module LlmCostTracker
+  module Reconciliation
+    module Sources
+      module Coercion
+        module_function
+
+        def symbolize(hash)
+          return hash if hash.is_a?(Hash) && hash.keys.all?(Symbol)
+
+          hash.to_h.transform_keys { |key| key.to_s.to_sym }
+        end
+
+        def normalized_epoch(value)
+          return value.to_i if value.is_a?(Numeric)
+
+          Time.parse(value.to_s).utc.to_i
+        rescue ArgumentError
+          value.to_s
+        end
+
+        def coerce_hash(response, label:)
+          return {} if response.nil?
+          return symbolize(response) if response.is_a?(Hash)
+
+          parsed = JSON.parse(response.to_s)
+          raise ArgumentError, "#{label} payload must be a JSON object" unless parsed.is_a?(Hash)
+
+          symbolize(parsed)
+        rescue JSON::ParserError => e
+          raise ArgumentError, "Unable to parse #{label} payload: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/reconciliation/sources/openai_usage.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
 require "time"
 
+require_relative "coercion"
 require_relative "fingerprint"
 
 module LlmCostTracker
@@ -17,7 +17,7 @@ module LlmCostTracker
         module_function
 
         def parse(response, authority: AUTHORITY_COST_API, row_type: ROW_TYPE_COST)
-          payload = coerce_hash(response)
+          payload = Coercion.coerce_hash(response, label: "OpenAI Costs")
           buckets = Array(payload[:data])
           buckets.flat_map do |bucket|
             rows_for_bucket(bucket, authority: authority, row_type: row_type)
@@ -25,7 +25,7 @@ module LlmCostTracker
         end
 
         def rows_for_bucket(bucket, authority:, row_type:)
-          bucket = symbolize(bucket)
+          bucket = Coercion.symbolize(bucket)
           start_time = bucket[:start_time]
           end_time = bucket[:end_time]
           return [] unless start_time && end_time
@@ -44,8 +44,8 @@ module LlmCostTracker
         end
 
         def row_for_result(raw, period_start:, period_end:, start_time:, end_time:, authority:, row_type:)
-          result = symbolize(raw)
-          amount = symbolize(result[:amount] || {})
+          result = Coercion.symbolize(raw)
+          amount = Coercion.symbolize(result[:amount] || {})
           billed_amount = amount[:value]
           return nil if billed_amount.nil?
 
@@ -93,19 +93,11 @@ module LlmCostTracker
         end
 
         def fingerprint_for(result, start_time:, end_time:)
-          attributes = result.merge(start_time: normalized_epoch(start_time),
-                                    end_time: normalized_epoch(end_time))
+          attributes = result.merge(start_time: Coercion.normalized_epoch(start_time),
+                                    end_time: Coercion.normalized_epoch(end_time))
           Fingerprint.compute(FINGERPRINT_KEYS, attributes)
         end
 
-        def normalized_epoch(value)
-          return value.to_i if value.is_a?(Numeric)
-
-          Time.parse(value.to_s).utc.to_i
-        rescue ArgumentError
-          value.to_s
-        end
-
         def epoch_to_date(value)
           return Time.at(Integer(value)).utc.to_date if value.is_a?(Numeric) || value.to_s.match?(/\A\d+\z/)
 
@@ -120,22 +112,6 @@ module LlmCostTracker
                  end
           (time - 1).utc.to_date
         end
-
-        def coerce_hash(response)
-          return {} if response.nil?
-          return symbolize(response) if response.is_a?(Hash)
-
-          parsed = JSON.parse(response.to_s)
-          raise ArgumentError, "OpenAI Costs payload must be a JSON object" unless parsed.is_a?(Hash)
-
-          symbolize(parsed)
-        rescue JSON::ParserError => e
-          raise ArgumentError, "Unable to parse OpenAI Costs payload: #{e.message}"
-        end
-
-        def symbolize(hash)
-          hash.to_h.transform_keys { |key| key.to_s.to_sym }
-        end
       end
     end
   end

data/lib/llm_cost_tracker/report/formatter.rb

@@ -4,18 +4,18 @@ module LlmCostTracker
   class Report
     class Formatter
       TOP_LIMIT = 5
-      NAME_COLUMN_WIDTH = 28
-      TOP_CALL_COLUMN_WIDTH = 32
+      MIN_COLUMN_WIDTH = 28
 
-      def initialize(data)
+      def initialize(data, color: $stdout.tty?)
         @data = data
+        @color = color
       end
 
       def to_s
-        lines = ["LLM Cost Report (last #{@data.days} days)", ""]
+        lines = [bold("LLM Cost Report (last #{@data.days} days)"), ""]
         append_summary(lines)
-        append_cost_section(lines, "By provider", @data.cost_by_provider)
-        append_cost_section(lines, "By model", @data.cost_by_model)
+        append_cost_section(lines, "By provider", @data.cost_by_provider) { |row| row.name.to_s }
+        append_cost_section(lines, "By model", @data.cost_by_model) { |row| row.name.to_s }
         append_tag_sections(lines)
         append_top_calls(lines)
         lines.join("\n")
@@ -27,36 +27,37 @@ module LlmCostTracker
         lines << "Total cost: #{money(@data.total_cost)}"
         lines << "Requests: #{@data.requests_count}"
         lines << "Avg latency: #{average_latency}"
-        lines << "Unknown pricing: #{@data.unknown_pricing_count}"
+        lines << "Unknown pricing: #{colored_unknown_pricing(@data.unknown_pricing_count)}"
       end
 
-      def append_cost_section(lines, title, rows)
+      def append_cost_section(lines, title, rows, &name_for)
         lines << ""
-        lines << "#{title}:"
+        lines << bold("#{title}:")
         return lines << "  none" if rows.empty?
 
-        rows.first(TOP_LIMIT).each do |row|
-          lines << "  #{row.name.to_s.ljust(NAME_COLUMN_WIDTH)} #{money(row.total_cost)}"
+        visible = rows.first(TOP_LIMIT)
+        width = column_width(visible, &name_for)
+        visible.each do |row|
+          lines << "  #{name_for.call(row).ljust(width)} #{money(row.total_cost)}"
         end
       end
 
       def append_tag_sections(lines)
         @data.cost_by_tags.each do |tag_key, rows|
-          append_cost_section(lines, "By tag (#{tag_key})", rows)
+          append_cost_section(lines, "By tag (#{tag_key})", rows) { |row| row.name.to_s }
         end
       end
 
       def append_top_calls(lines)
-        lines << ""
-        lines << "Top expensive calls:"
-        return lines << "  none" if @data.top_calls.empty?
-
-        @data.top_calls.first(TOP_LIMIT).each do |call|
-          label = "#{call.provider}/#{call.model}"
-          lines << "  #{label.ljust(TOP_CALL_COLUMN_WIDTH)} #{money(call.total_cost)}"
+        append_cost_section(lines, "Top expensive calls", @data.top_calls) do |call|
+          "#{call.provider}/#{call.model}"
         end
       end
 
+      def column_width(rows, &name_for)
+        [MIN_COLUMN_WIDTH, rows.map { |row| name_for.call(row).length }.max.to_i].max
+      end
+
       def average_latency
         @data.average_latency_ms ? "#{@data.average_latency_ms.round}ms" : "n/a"
       end
@@ -64,6 +65,18 @@ module LlmCostTracker
       def money(value)
         "$#{format('%.6f', value.to_f)}"
       end
+
+      def colored_unknown_pricing(count)
+        return count.to_s unless @color
+
+        count.to_i.positive? ? "\e[33m#{count}\e[0m" : "\e[32m#{count}\e[0m"
+      end
+
+      def bold(text)
+        return text unless @color
+
+        "\e[1m#{text}\e[0m"
+      end
     end
   end
 end

data/lib/llm_cost_tracker/report.rb

@@ -15,10 +15,6 @@ module LlmCostTracker
         )
 
         Formatter.new(report_data).to_s
-      rescue LoadError => e
-        "Unable to build LLM cost report: ActiveRecord storage is unavailable (#{e.message})"
-      rescue StandardError => e
-        "Unable to build LLM cost report: #{e.class}: #{e.message}"
       end
     end
   end

data/lib/llm_cost_tracker/retention.rb

@@ -32,6 +32,14 @@ module LlmCostTracker
           .delete_all
       end
 
+      def prune_inbox(older_than:, now: Time.now.utc)
+        cutoff = resolve_cutoff(older_than, now)
+        require_relative "ingestion"
+        return 0 unless LlmCostTracker::Ingestion::InboxEntry.table_exists?
+
+        LlmCostTracker::Ingestion::InboxEntry.where(tracked_at: ...cutoff).delete_all
+      end
+
       private
 
       def resolve_cutoff(older_than, now)
@@ -61,20 +69,24 @@ module LlmCostTracker
 
       def prune_batch(cutoff, batch_size)
         LlmCostTracker::Call.transaction do
-          rows = pluck_prunable(cutoff, batch_size)
+          cache_rollups = LlmCostTracker.configuration.cache_rollups
+          rows = pluck_prunable(cutoff, batch_size, with_rollup_columns: cache_rollups)
           next 0 if rows.empty?
 
-          deleted = LlmCostTracker::Call.where(id: rows.map(&:first)).delete_all
-          if deleted.positive? && LlmCostTracker.configuration.cache_rollups
-            LlmCostTracker::Ledger::Rollups.decrement!(rows)
-          end
+          ids = cache_rollups ? rows.map(&:first) : rows
+          deleted = LlmCostTracker::Call.where(id: ids).delete_all
+          LlmCostTracker::Ledger::Rollups.decrement!(rows) if cache_rollups && deleted.positive?
           deleted
         end
       end
 
-      def pluck_prunable(cutoff, batch_size)
-        LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
-                            .pluck(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider)
+      def pluck_prunable(cutoff, batch_size, with_rollup_columns:)
+        relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
+        if with_rollup_columns
+          relation.pluck(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider)
+        else
+          relation.pluck(:id)
+        end
       end
     end
   end

data/lib/llm_cost_tracker/tags/sanitizer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/inflections"
-require "json"
 
 module LlmCostTracker
   module Tags
@@ -24,7 +23,7 @@ module LlmCostTracker
       class << self
         def call(tags, config: LlmCostTracker.configuration)
           tags = (tags || {}).to_h
-          redacted = Array(config.redacted_tag_keys).map { |key| normalized_key(key) }
+          redacted = config.normalized_redacted_tag_keys
           limit = [config.max_tag_value_bytesize.to_i, 0].max
           max_count = [config.max_tag_count.to_i, 0].max
           tags.to_a.last(max_count).each_with_object({}) do |(key, value), sanitized|
@@ -32,6 +31,18 @@ module LlmCostTracker
           end
         end
 
+        def cap(tags, config: LlmCostTracker.configuration)
+          tags = (tags || {}).to_h
+          max_count = [config.max_tag_count.to_i, 0].max
+          return tags if tags.size <= max_count
+
+          tags.to_a.last(max_count).to_h
+        end
+
+        def normalized_key(key)
+          key.to_s.underscore.gsub(/[^a-z0-9]+/, "_").delete_prefix("_").delete_suffix("_")
+        end
+
         private
 
         def sanitized_value(key, value, redacted, limit)
@@ -92,27 +103,12 @@ module LlmCostTracker
           redacted.any? { |candidate| redacted_key_component?(normalized, candidate) }
         end
 
-        def normalized_key(key)
-          key.to_s.underscore.gsub(/[^a-z0-9]+/, "_").delete_prefix("_").delete_suffix("_")
-        end
-
         def redacted_key_component?(key, candidate)
           key == candidate ||
             key.start_with?("#{candidate}_") ||
             key.end_with?("_#{candidate}") ||
             key.include?("_#{candidate}_")
         end
-
-        def value_string(value)
-          case value
-          when Hash, Array
-            JSON.generate(value)
-          else
-            value.to_s
-          end
-        rescue JSON::GeneratorError, TypeError
-          value.to_s
-        end
       end
     end
   end

data/lib/llm_cost_tracker/token_usage.rb

@@ -21,6 +21,10 @@ module LlmCostTracker
     :total_tokens,
     :hidden_output_tokens
   ) do
+    def priced_quantities
+      Billing::Components::TOKEN_PRICED.to_h { |component| [component.key, public_send(component.token_key)] }
+    end
+
     def self.build_from_tokens(tokens)
       return tokens if tokens.is_a?(self)
       raise ArgumentError, "tokens must be a Hash, got #{tokens.class}" unless tokens.respond_to?(:to_h)