llm_cost_tracker 0.10.0 → 0.12.0

data/app/views/llm_cost_tracker/reconciliation/index.html.erb

@@ -1,183 +0,0 @@
-<section class="lct-panel">
-  <div class="lct-toolbar-head">
-    <h2 class="lct-section-title">Provider Invoice Reconciliation <span class="lct-badge lct-badge-warn">Experimental</span></h2>
-    <% if @last_imported_at %>
-      <p class="lct-state-copy">Last import: <%= @last_imported_at.utc.iso8601 %></p>
-    <% end %>
-  </div>
-  <p class="lct-state-copy">
-    Experimental in v0.9.0 — public API may change in v0.9.x based on feedback.
-    <%= link_to "Open an issue", "https://github.com/sergey-homenko/llm_cost_tracker/issues", target: "_blank", rel: "noopener" %>
-    if you use it.
-  </p>
-</section>
-
-<% if flash[:notice] %>
-  <section class="lct-panel"><p class="lct-state-copy"><%= flash[:notice] %></p></section>
-<% end %>
-<% if flash[:alert] %>
-  <section class="lct-panel"><p class="lct-state-copy"><%= flash[:alert] %></p></section>
-<% end %>
-
-<% if @configured_importers.any? %>
-  <section class="lct-panel">
-    <h3 class="lct-section-title">Trigger import</h3>
-    <% @configured_importers.each_key do |source| %>
-      <%= button_to "Re-import #{source}",
-            reconciliation_import_path(source: source),
-            method: :post,
-            class: "lct-button lct-button-secondary" %>
-    <% end %>
-  </section>
-<% end %>
-
-<% if !@reconciliation_enabled %>
-  <section class="lct-panel lct-empty">
-    <h2 class="lct-state-title">Reconciliation disabled</h2>
-    <p class="lct-state-copy">
-      Provider invoice reconciliation is opt-in because it requires admin/org-level
-      provider API keys (OpenAI <code>sk-admin-…</code>, Anthropic admin keys, GCP
-      <code>billing.viewer</code>) — separate from the runtime inference key the
-      tracker uses. Enable explicitly in the initializer:
-    </p>
-    <pre class="lct-state-pre"><code>LlmCostTracker.configure do |config|
-  config.reconciliation_enabled = true
-end</code></pre>
-  </section>
-<% elsif !@reconciliation_installed %>
-  <section class="lct-panel lct-empty">
-    <h2 class="lct-state-title">Reconciliation not installed</h2>
-    <p class="lct-state-copy">
-      Run the optional migration to create the reconciliation tables:
-    </p>
-    <pre class="lct-state-pre"><code>bin/rails generate llm_cost_tracker:reconciliation
-bin/rails db:migrate</code></pre>
-  </section>
-<% elsif @diffs.empty? %>
-  <section class="lct-panel lct-empty">
-    <h2 class="lct-state-title">No invoices imported yet</h2>
-    <p class="lct-state-copy">
-      Reconciliation compares provider-side invoices against local cost. Once you import
-      invoice rows via <code>LlmCostTracker::Reconciliation.import</code>, they appear here.
-    </p>
-  </section>
-<% else %>
-  <section class="lct-panel">
-    <h3 class="lct-section-title">Latest period per source / provider / currency</h3>
-    <table class="lct-table">
-      <thead>
-        <tr>
-          <th>Source</th>
-          <th>Provider</th>
-          <th>Currency</th>
-          <th>Period</th>
-          <th class="lct-num">Provider total</th>
-          <th class="lct-num">Local total</th>
-          <th class="lct-num">Delta</th>
-          <th class="lct-num">%</th>
-          <th>Status</th>
-        </tr>
-      </thead>
-      <tbody>
-        <% @diffs.each do |diff| %>
-          <tr>
-            <td><%= diff.source %></td>
-            <td><%= diff.provider %></td>
-            <td><%= diff.currency %></td>
-            <td><%= diff.period_start %> → <%= diff.period_end %></td>
-            <td class="lct-num"><%= money(diff.provider_total) %></td>
-            <td class="lct-num"><%= money(diff.local_total) %></td>
-            <td class="lct-num"><%= money(diff.delta_amount) %></td>
-            <td class="lct-num"><%= diff.delta_percent.nil? ? "—" : "#{diff.delta_percent}%" %></td>
-            <td>
-              <% if diff.aligned?(threshold_percent: @threshold) %>
-                <span class="lct-badge lct-badge-ok">Aligned</span>
-              <% else %>
-                <span class="lct-badge lct-badge-warn">Drift</span>
-              <% end %>
-            </td>
-          </tr>
-        <% end %>
-      </tbody>
-    </table>
-  </section>
-
-  <% @diffs.each do |diff| %>
-    <% next if diff.unmatched_provider_rows.empty? && diff.unmatched_local_calls.empty? && diff.non_cost_rows.empty? %>
-
-    <section class="lct-panel">
-      <h3 class="lct-section-title"><%= diff.source %> / <%= diff.provider %> / <%= diff.currency %> — drill down</h3>
-
-      <% if diff.unmatched_provider_rows.any? %>
-        <h4 class="lct-state-title">
-          Provider rows without a matching local call
-          <% if diff.unmatched_provider_rows_truncated? %>
-            <small>(showing <%= diff.unmatched_provider_rows.size %> of <%= diff.unmatched_provider_rows_total %>, ranked by billed amount)</small>
-          <% end %>
-        </h4>
-        <table class="lct-table">
-          <thead>
-            <tr><th>External ID</th><th>Match basis</th><th>Attribution</th><th class="lct-num">Billed</th></tr>
-          </thead>
-          <tbody>
-            <% diff.unmatched_provider_rows.each do |row| %>
-              <tr>
-                <td><%= row[:external_id] %></td>
-                <td><%= row[:match_basis] %></td>
-                <td><%= attribution_summary(row[:attribution]) %></td>
-                <td class="lct-num"><%= optional_money(row[:billed_amount]) %></td>
-              </tr>
-            <% end %>
-          </tbody>
-        </table>
-      <% end %>
-
-      <% if diff.unmatched_local_calls.any? %>
-        <h4 class="lct-state-title">
-          Local calls no provider invoice can explain
-          <% if diff.unmatched_local_calls_truncated? %>
-            <small>(showing <%= diff.unmatched_local_calls.size %> of <%= diff.unmatched_local_calls_total %>, ranked by total cost)</small>
-          <% end %>
-        </h4>
-        <table class="lct-table">
-          <thead>
-            <tr><th>Attribution</th><th class="lct-num">Calls</th><th class="lct-num">Total cost</th></tr>
-          </thead>
-          <tbody>
-            <% diff.unmatched_local_calls.each do |row| %>
-              <tr>
-                <td><%= attribution_summary(row[:attribution]) %></td>
-                <td class="lct-num"><%= number(row[:count]) %></td>
-                <td class="lct-num"><%= money(row[:total_cost]) %></td>
-              </tr>
-            <% end %>
-          </tbody>
-        </table>
-      <% end %>
-
-      <% if diff.non_cost_rows.any? %>
-        <h4 class="lct-state-title">
-          Non-cost evidence (free quota, credits, adjustments)
-          <% if diff.non_cost_rows_truncated? %>
-            <small>(showing <%= diff.non_cost_rows.size %> of <%= diff.non_cost_rows_total %>, ranked by amount)</small>
-          <% end %>
-        </h4>
-        <table class="lct-table">
-          <thead>
-            <tr><th>Row type</th><th>Meter</th><th>Attribution</th><th class="lct-num">Amount</th></tr>
-          </thead>
-          <tbody>
-            <% diff.non_cost_rows.each do |row| %>
-              <tr>
-                <td><%= row[:row_type] %></td>
-                <td><%= row[:meter] %></td>
-                <td><%= attribution_summary(row[:attribution]) %></td>
-                <td class="lct-num"><%= optional_money(row[:billed_amount]) %></td>
-              </tr>
-            <% end %>
-          </tbody>
-        </table>
-      <% end %>
-    </section>
-  <% end %>
-<% end %>

data/app/views/llm_cost_tracker/shared/_active_filters.html.erb

@@ -1,16 +0,0 @@
-<% if chips.any? %>
-  <div class="lct-chip-row" aria-label="Active filters">
-    <% chips.each do |chip| %>
-      <span class="lct-chip">
-        <span class="lct-chip-label"><%= chip[:label] %></span>
-        <span><%= chip[:value] %></span>
-        <% if chip[:path] %>
-          <%= link_to "×", chip[:path], class: "lct-chip-remove", aria: { label: "Remove #{chip[:label]} #{chip[:value]}" } %>
-        <% end %>
-      </span>
-    <% end %>
-    <% if local_assigns[:clear_path] %>
-      <%= link_to "Clear all", clear_path, class: "lct-clear-link" %>
-    <% end %>
-  </div>
-<% end %>

data/app/views/llm_cost_tracker/shared/_filters.html.erb

@@ -1,66 +0,0 @@
-<%
-  fields = local_assigns.fetch(:fields, %i[from to provider model stream])
-  default_range = LlmCostTracker::Dashboard::DateRange.call(params: params)
-  defaults = {
-    from: default_range.from.iso8601,
-    to: default_range.to.iso8601
-  }.merge(local_assigns.fetch(:defaults, {}))
-  reset_path = local_assigns.fetch(:reset_path, path)
-  filter_scope = local_assigns.fetch(:filter_scope, params)
-%>
-
-<form class="lct-filters" action="<%= path %>" method="get">
-  <% local_assigns.fetch(:hidden_fields, {}).each do |key, val| %>
-    <%= hidden_field_tag(key, val) %>
-  <% end %>
-  <div class="lct-filter-row">
-    <% if fields.include?(:from) %>
-      <div class="lct-field">
-        <label for="lct-filter-from">From</label>
-        <input id="lct-filter-from" type="date" name="from" value="<%= params[:from] || defaults[:from] %>">
-      </div>
-    <% end %>
-
-    <% if fields.include?(:to) %>
-      <div class="lct-field">
-        <label for="lct-filter-to">To</label>
-        <input id="lct-filter-to" type="date" name="to" value="<%= params[:to] || defaults[:to] %>">
-      </div>
-    <% end %>
-
-    <% if fields.include?(:provider) %>
-      <div class="lct-field">
-        <label for="lct-filter-provider">Provider</label>
-        <%= select_tag :provider,
-                       options_for_select(provider_filter_options(filter_params: filter_scope), params[:provider]),
-                       include_blank: "All providers",
-                       id: "lct-filter-provider" %>
-      </div>
-    <% end %>
-
-    <% if fields.include?(:model) %>
-      <div class="lct-field">
-        <label for="lct-filter-model">Model</label>
-        <%= select_tag :model,
-                       options_for_select(model_filter_options(filter_params: filter_scope), params[:model]),
-                       include_blank: "All models",
-                       id: "lct-filter-model" %>
-      </div>
-    <% end %>
-
-    <% if fields.include?(:stream) %>
-      <div class="lct-field">
-        <label for="lct-filter-stream">Stream</label>
-        <%= select_tag :stream,
-                       options_for_select(LlmCostTracker::DashboardFilterHelper::STREAM_FILTER_OPTIONS, params[:stream]),
-                       include_blank: "All calls",
-                       id: "lct-filter-stream" %>
-      </div>
-    <% end %>
-
-    <div class="lct-filter-actions">
-      <button class="lct-button" type="submit">Apply</button>
-      <%= link_to("Reset", reset_path, class: "lct-button lct-button-secondary") if any_filter_applied? %>
-    </div>
-  </div>
-</form>

data/app/views/llm_cost_tracker/shared/_sort.html.erb

@@ -1,13 +0,0 @@
-<%
-  current = local_assigns.fetch(:current).to_s
-  options = local_assigns.fetch(:options)
-%>
-
-<nav class="lct-sort" aria-label="Sort by">
-  <% options.each do |label, value| %>
-    <%= link_to label,
-                path_for_sort.call(value),
-                class: ["lct-sort-option", ("is-active" if current == value.to_s)].compact.join(" "),
-                aria: ({ current: "true" } if current == value.to_s) %>
-  <% end %>
-</nav>

data/lib/llm_cost_tracker/billing/components.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "psych"
-
-require_relative "../errors"
-
-module LlmCostTracker
-  module Billing
-    RATE_BASES = %i[
-      per_million_tokens
-      per_million_characters
-      per_request
-      per_1k_requests
-      per_session
-      per_hour
-      per_gb_day
-      per_image
-    ].freeze
-
-    RATE_BASIS_QUANTITIES = {
-      per_million_tokens: 1_000_000,
-      per_million_characters: 1_000_000,
-      per_request: 1,
-      per_1k_requests: 1_000,
-      per_session: 1,
-      per_hour: 1,
-      per_gb_day: 1,
-      per_image: 1
-    }.freeze
-
-    DEFAULT_RATE_BASIS_BY_UNIT = {
-      token: :per_million_tokens,
-      character: :per_million_characters,
-      request: :per_request,
-      session: :per_session,
-      hour: :per_hour,
-      image: :per_image
-    }.freeze
-
-    module Components
-      Component = Data.define(
-        :key,
-        :kind,
-        :direction,
-        :modality,
-        :cache_state,
-        :unit,
-        :category,
-        :token_key,
-        :cost_key,
-        :rate_basis
-      )
-
-      REQUIRED_FIELDS = %i[key kind direction modality cache_state unit category].freeze
-      DEFINITIONS_PATH = File.expand_path("components.yml", __dir__)
-
-      def self.load_registry
-        Psych.safe_load_file(DEFINITIONS_PATH, permitted_classes: [], symbolize_names: true)
-             .map { |attributes| build(attributes) }
-             .freeze
-      end
-
-      def self.build(attributes)
-        missing = REQUIRED_FIELDS - attributes.keys
-        raise Error, "components.yml entry missing #{missing.join(', ')}: #{attributes.inspect}" if missing.any?
-
-        unit = attributes.fetch(:unit).to_sym
-        rate_basis = attributes[:rate_basis]&.to_sym || Billing::DEFAULT_RATE_BASIS_BY_UNIT[unit]
-        if rate_basis.nil?
-          raise Error, "components.yml entry needs rate_basis for unit #{unit.inspect}: #{attributes.inspect}"
-        end
-        unless Billing::RATE_BASES.include?(rate_basis)
-          raise Error, "components.yml entry has unknown rate_basis #{rate_basis.inspect}: #{attributes.inspect}"
-        end
-
-        Component.new(
-          key: attributes.fetch(:key).to_sym,
-          kind: attributes.fetch(:kind).to_sym,
-          direction: attributes.fetch(:direction).to_sym,
-          modality: attributes.fetch(:modality).to_sym,
-          cache_state: attributes.fetch(:cache_state).to_sym,
-          unit: unit,
-          category: attributes.fetch(:category).to_sym,
-          token_key: attributes[:token_key]&.to_sym,
-          cost_key: attributes[:cost_key]&.to_sym,
-          rate_basis: rate_basis
-        )
-      end
-
-      REGISTRY = load_registry
-      BY_KEY = REGISTRY.to_h { |component| [component.key, component] }.freeze
-      TOKEN_PRICED = REGISTRY.select { |component| component.token_key && component.cost_key }.freeze
-    end
-  end
-end

data/lib/llm_cost_tracker/capture/stream.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Capture
-    module Stream
-      LIMIT_BYTES = 1_048_576
-    end
-  end
-end

data/lib/llm_cost_tracker/doctor/capture_verifier.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "check"
-require_relative "../ingestion"
-
-module LlmCostTracker
-  class Doctor
-    class CaptureVerifier
-      class << self
-        def call
-          new.checks
-        end
-
-        def report(checks = call)
-          (["LLM Cost Tracker capture verification"] + checks.map do |check|
-            "[#{check.status}] #{check.name}: #{check.message}"
-          end).join("\n")
-        end
-
-        def healthy?(checks = call)
-          checks.none? { |check| check.status == :error }
-        end
-      end
-
-      def checks
-        [
-          enabled_check,
-          *integration_checks,
-          *storage_checks
-        ].compact
-      end
-
-      private
-
-      def enabled_check
-        return Check.new(:ok, "tracking", "enabled") if LlmCostTracker.configuration.enabled
-
-        Check.new(:error, "tracking", "disabled; set config.enabled = true before verifying capture")
-      end
-
-      def integration_checks
-        enabled = LlmCostTracker.configuration.instrumented_integrations
-        if enabled.empty?
-          return [
-            Check.new(:ok, "sdk integrations", "none enabled; Faraday middleware and manual capture remain available")
-          ]
-        end
-
-        LlmCostTracker::Integrations.checks.map do |check|
-          check.with(name: "sdk integration #{check.name}")
-        end
-      end
-
-      def storage_checks
-        LlmCostTracker::Ingestion.verify
-      rescue LlmCostTracker::Error => e
-        [Check.new(:error, "storage", e.message)]
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/doctor/check.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  class Doctor
-    Check = Data.define(:status, :name, :message)
-  end
-end

data/lib/llm_cost_tracker/doctor/cost_drift_check.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-
-require_relative "check"
-require_relative "probe"
-require_relative "../ledger/rollups"
-
-module LlmCostTracker
-  class Doctor
-    class CostDriftCheck
-      SAMPLE_SIZE = 200
-      EPSILON = BigDecimal("0.00000001")
-
-      def call
-        return unless Probe.table_exists?("llm_cost_tracker_calls")
-        return unless Probe.table_exists?("llm_cost_tracker_call_line_items")
-
-        sampled = LlmCostTracker::Call
-                  .where.not(total_cost: nil)
-                  .where(cost_status: %w[complete free partial])
-                  .order(id: :desc)
-                  .limit(SAMPLE_SIZE)
-                  .pluck(:id, :total_cost, :cost_status)
-        return Check.new(:ok, "cost drift", "no priced calls to inspect") if sampled.empty?
-
-        line_item_totals = LlmCostTracker::CallLineItem
-                           .where(llm_cost_tracker_call_id: sampled.map(&:first))
-                           .where(currency: Ledger::Rollups::DEFAULT_CURRENCY)
-                           .group(:llm_cost_tracker_call_id)
-                           .sum(:cost)
-
-        drifted = sampled.filter_map do |id, total_cost, cost_status|
-          line_total = line_item_totals[id] || BigDecimal("0")
-          header = BigDecimal(total_cost.to_s)
-          next if cost_status == "partial" && header >= line_total
-          next if (header - line_total).abs <= EPSILON
-
-          "##{id}: header=#{header.to_s('F')} line_items=#{line_total.to_s('F')}"
-        end
-
-        if drifted.empty?
-          return Check.new(:ok, "cost drift",
-                           "header total_cost matches line items in #{sampled.size} sampled calls")
-        end
-
-        Check.new(
-          :warn,
-          "cost drift",
-          "header total_cost diverges from line items in #{drifted.size}/#{sampled.size} sampled calls: " \
-          "#{drifted.first(5).join('; ')}#{'; ...' if drifted.size > 5}"
-        )
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/doctor/invoice_reconciliation_check.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-
-require_relative "check"
-require_relative "probe"
-require_relative "../ledger/schema/adapter"
-
-module LlmCostTracker
-  class Doctor
-    class InvoiceReconciliationCheck
-      def call
-        return unless LlmCostTracker.reconciliation_enabled?
-        return unless Probe.table_exists?("llm_cost_tracker_provider_invoices")
-        return if no_imports?
-
-        scopes = imported_scopes
-        return Check.new(:ok, "invoice reconciliation", "no provider invoices imported yet") if scopes.empty?
-
-        non_canonical = non_canonical_currency_check
-        checks = scopes.map { |scope| check_scope_safely(scope) }
-        checks << non_canonical if non_canonical
-        checks
-      rescue StandardError => e
-        Check.new(:error, "invoice reconciliation", e.message)
-      end
-
-      private
-
-      def no_imports?
-        LlmCostTracker::ProviderInvoice.none?
-      end
-
-      def non_canonical_currency_check
-        legacy = LlmCostTracker::ProviderInvoice.where("currency <> UPPER(currency)").count
-        return nil if legacy.zero?
-
-        Check.new(
-          :warn,
-          "invoice reconciliation: currency canonicalisation",
-          "#{legacy} provider invoice row(s) stored with non-uppercase currency. Diff queries " \
-          "are case-sensitive — run " \
-          "`UPDATE llm_cost_tracker_provider_invoices SET currency = UPPER(currency);` to backfill."
-        )
-      end
-
-      def threshold
-        Reconciliation::DEFAULT_THRESHOLD_PERCENT
-      end
-
-      def imported_scopes
-        connection = LlmCostTracker::ProviderInvoice.connection
-        provider_expr =
-          if Ledger::Schema::Adapter.postgresql?(connection)
-            Arel.sql("metadata->>'provider'")
-          else
-            Arel.sql("JSON_UNQUOTE(JSON_EXTRACT(metadata, '$.provider'))")
-          end
-        LlmCostTracker::ProviderInvoice
-          .group(:source, provider_expr, :currency)
-          .order(:source, :currency)
-          .pluck(:source, provider_expr, :currency)
-          .map { |source, provider, currency| { source: source, provider: provider, currency: currency.upcase } }
-      end
-
-      def scope_label(scope)
-        "#{scope[:source]}/#{scope[:provider]}/#{scope[:currency]}"
-      end
-
-      def check_scope_safely(scope)
-        check_scope(scope)
-      rescue ArgumentError => e
-        Check.new(:warn, "invoice reconciliation: #{scope_label(scope)}", e.message)
-      end
-
-      def check_scope(scope)
-        window = latest_window_for(scope)
-        return stale_check(scope) if window.nil?
-
-        diff = run_diff(scope, window)
-        return ok_check(scope, window, diff) if diff.aligned?(threshold_percent: threshold)
-
-        warn_check(scope, window, diff)
-      end
-
-      def scope_relation(scope)
-        relation = LlmCostTracker::ProviderInvoice
-                   .where(source: scope[:source], currency: scope[:currency])
-        provider = scope[:provider]
-        return relation if provider.nil? || provider.to_s.empty?
-
-        connection = LlmCostTracker::ProviderInvoice.connection
-        if Ledger::Schema::Adapter.postgresql?(connection)
-          relation.where("metadata->>'provider' = ?", provider)
-        else
-          relation.where("JSON_UNQUOTE(JSON_EXTRACT(metadata, '$.provider')) = ?", provider)
-        end
-      end
-
-      def latest_window_for(scope)
-        latest = scope_relation(scope)
-                 .select(:period_start, :period_end)
-                 .order(period_end: :desc, period_start: :desc)
-                 .limit(1)
-                 .first
-        return nil unless latest
-        return nil if (Time.now.utc.to_date - latest.period_end).to_i > Reconciliation::INVOICE_FRESHNESS_DAYS
-
-        latest
-      end
-
-      def run_diff(scope, window)
-        Reconciliation.diff(
-          source: scope[:source],
-          provider: scope[:provider],
-          currency: scope[:currency],
-          period_start: window.period_start,
-          period_end: window.period_end
-        )
-      end
-
-      def stale_check(scope)
-        latest = scope_relation(scope).maximum(:period_end)
-        return scope_unreachable_check(scope) if latest.nil?
-
-        days = (Time.now.utc.to_date - latest).to_i
-        Check.new(
-          :warn,
-          "invoice reconciliation: #{scope_label(scope)}",
-          "no invoice imported in #{days} days (threshold #{Reconciliation::INVOICE_FRESHNESS_DAYS} days); " \
-          "run reconciliation import"
-        )
-      end
-
-      def scope_unreachable_check(scope)
-        Check.new(
-          :warn,
-          "invoice reconciliation: #{scope_label(scope)}",
-          "scope grouped invoices but the filter (likely currency case mismatch) matches zero rows; " \
-          "the currency-canonicalisation check below points at the backfill SQL"
-        )
-      end
-
-      def ok_check(scope, window, diff)
-        Check.new(
-          :ok,
-          "invoice reconciliation: #{scope_label(scope)}",
-          "#{window.period_start}..#{window.period_end} aligned " \
-          "(local=#{diff.local_total.to_s('F')}, provider=#{diff.provider_total.to_s('F')})"
-        )
-      end
-
-      def warn_check(scope, window, diff)
-        Check.new(
-          :warn,
-          "invoice reconciliation: #{scope_label(scope)}",
-          "#{window.period_start}..#{window.period_end} drift " \
-          "delta=#{diff.delta_amount.to_s('F')} (#{diff.delta_percent}%) " \
-          "exceeds #{threshold}% threshold"
-        )
-      end
-    end
-  end
-end