llm_cost_tracker 0.6.1 → 0.7.1

data/lib/llm_cost_tracker/doctor/ingestion_check.rb

@@ -1,44 +1,40 @@
 # frozen_string_literal: true
 
-require "time"
+require_relative "check"
+require_relative "../ingestion"
 
 module LlmCostTracker
   class Doctor
     class IngestionCheck
       PENDING_AGE_WARNING_SECONDS = 60
 
-      def self.call(check_class)
-        new(check_class).call
-      end
-
-      def initialize(check_class)
-        @check_class = check_class
-      end
-
       def call
-        return unless active_record_storage? && llm_api_calls_table?
+        return unless table_exists?("llm_api_calls")
 
         missing = missing_parts
         if missing.empty?
           quarantined = quarantined_count
           if quarantined.positive?
-            return check_class.new(:warn, "durable ingestion", "#{quarantined} inbox events quarantined after retries")
+            return Check.new(:warn, "durable ingestion", "#{quarantined} inbox events quarantined after retries")
           end
 
           pending = pending_snapshot
-          if stale_pending?(pending)
-            return check_class.new(
+          pending_count = pending.try(:pending_count).to_i
+          oldest_pending_at = pending.try(:oldest_created_at)&.to_time&.utc
+          pending_age = oldest_pending_at && (Time.now.utc - oldest_pending_at)
+          if pending_count.positive? && pending_age && pending_age >= PENDING_AGE_WARNING_SECONDS
+            return Check.new(
               :warn,
               "durable ingestion",
-              "#{pending.fetch(:count)} inbox events pending; oldest pending age #{pending_age(pending).round}s"
+              "#{pending_count} inbox events pending; oldest pending age #{pending_age.round}s"
             )
           end
 
-          return check_class.new(:ok, "durable ingestion", "inbox and ingestor lease tables available")
+          return Check.new(:ok, "durable ingestion", "inbox and ingestor lease tables available")
         end
 
-        check_class.new(
-          :warn,
+        Check.new(
+          :error,
           "durable ingestion",
           "missing #{missing.join(', ')}; run bin/rails generate llm_cost_tracker:add_ingestion && bin/rails db:migrate"
         )
@@ -46,71 +42,36 @@ module LlmCostTracker
 
       private
 
-      attr_reader :check_class
-
       def missing_parts
         [
-          column_names("llm_api_calls").include?("event_id") ? nil : "llm_api_calls.event_id",
           table_exists?("llm_cost_tracker_inbox_events") ? nil : "llm_cost_tracker_inbox_events",
           table_exists?("llm_cost_tracker_ingestor_leases") ? nil : "llm_cost_tracker_ingestor_leases"
         ].compact
       end
 
-      def active_record_storage? = LlmCostTracker.configuration.storage_backend == :active_record
-
-      def llm_api_calls_table? = table_exists?("llm_api_calls")
-
       def table_exists?(name)
-        LlmCostTracker::LlmApiCall.connection.data_source_exists?(name)
+        LlmCostTracker::Ledger::Call.connection.data_source_exists?(name)
       rescue StandardError
         false
       end
 
-      def column_names(table) = LlmCostTracker::LlmApiCall.connection.columns(table).map(&:name)
-
       def quarantined_count
         return 0 unless table_exists?("llm_cost_tracker_inbox_events")
 
-        LlmCostTracker::LlmApiCall.connection.select_value(quarantined_sql).to_i
+        LlmCostTracker::Ingestion::Event
+          .where("attempts >= ?", LlmCostTracker::Ingestion::Event::MAX_ATTEMPTS)
+          .count
       rescue StandardError
         0
       end
 
-      def quarantined_sql
-        table = LlmCostTracker::LlmApiCall.connection.quote_table_name("llm_cost_tracker_inbox_events")
-        "SELECT COUNT(*) FROM #{table} WHERE attempts >= #{max_attempts}"
-      end
-
       def pending_snapshot
-        row = LlmCostTracker::LlmApiCall.connection.select_one(pending_sql) || {}
-        {
-          count: row.fetch("pending_count").to_i,
-          oldest_at: row["oldest_created_at"] && Time.parse(row.fetch("oldest_created_at").to_s).utc
-        }
+        LlmCostTracker::Ingestion::Event
+          .where("attempts < ?", LlmCostTracker::Ingestion::Event::MAX_ATTEMPTS)
+          .select("COUNT(*) AS pending_count, MIN(created_at) AS oldest_created_at")
+          .take
       rescue StandardError
-        { count: 0, oldest_at: nil }
-      end
-
-      def pending_sql
-        table = LlmCostTracker::LlmApiCall.connection.quote_table_name("llm_cost_tracker_inbox_events")
-        "SELECT COUNT(*) AS pending_count, MIN(created_at) AS oldest_created_at " \
-          "FROM #{table} WHERE attempts < #{max_attempts}"
-      end
-
-      def stale_pending?(pending)
-        pending.fetch(:count).positive? &&
-          pending.fetch(:oldest_at) &&
-          pending_age(pending) >= PENDING_AGE_WARNING_SECONDS
-      end
-
-      def pending_age(pending) = Time.now.utc - pending.fetch(:oldest_at)
-
-      def max_attempts
-        if defined?(LlmCostTracker::Storage::ActiveRecordInbox::MAX_ATTEMPTS)
-          LlmCostTracker::Storage::ActiveRecordInbox::MAX_ATTEMPTS
-        else
-          5
-        end
+        nil
       end
     end
   end

data/lib/llm_cost_tracker/doctor/price_check.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "date"
+
+require_relative "check"
+
+module LlmCostTracker
+  class Doctor
+    class PriceCheck
+      STALE_AFTER_DAYS = 30
+      REFRESH_COMMAND = "run bin/rails llm_cost_tracker:prices:refresh"
+
+      def call
+        path = LlmCostTracker.configuration.prices_file
+        return bundled_check unless path
+
+        count = LlmCostTracker::Pricing::Registry.file_prices(path).size
+        metadata = LlmCostTracker::Pricing::Registry.file_metadata(path)
+        updated_at = metadata["updated_at"] || metadata[:updated_at]
+        return configured_check(:warn, path, count, "metadata.updated_at missing; #{REFRESH_COMMAND}") unless updated_at
+
+        age_days = (Date.today - Date.iso8601(updated_at.to_s)).to_i
+        if age_days > STALE_AFTER_DAYS
+          return configured_check(
+            :warn,
+            path,
+            count,
+            "updated_at=#{updated_at} is older than #{STALE_AFTER_DAYS} days; #{REFRESH_COMMAND}"
+          )
+        end
+
+        configured_check(:ok, path, count, "updated_at=#{updated_at}")
+      rescue Date::Error
+        configured_check(
+          :warn,
+          path,
+          count,
+          "metadata.updated_at=#{updated_at.inspect} is invalid; #{REFRESH_COMMAND}"
+        )
+      rescue LlmCostTracker::Error => e
+        Check.new(:error, "prices", e.message)
+      end
+
+      private
+
+      def bundled_check
+        updated_at = LlmCostTracker::Pricing::Registry.metadata.fetch("updated_at", "unknown")
+        Check.new(
+          :warn,
+          "prices",
+          "using bundled prices updated_at=#{updated_at}; configure prices_file for production"
+        )
+      end
+
+      def configured_check(status, path, count, freshness)
+        Check.new(status, "prices", "loaded #{count} models from #{path}; #{freshness}")
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/doctor.rb

@@ -1,40 +1,39 @@
 # frozen_string_literal: true
 
-require_relative "price_freshness"
-require_relative "doctor/capture_check"
+require_relative "ledger"
+require_relative "doctor/check"
 require_relative "doctor/ingestion_check"
+require_relative "doctor/price_check"
+require_relative "generators/llm_cost_tracker/add_token_usage_generator"
 
 module LlmCostTracker
   class Doctor
-    Check = Data.define(:status, :name, :message)
-    CORE_COLUMNS = %w[provider model input_tokens output_tokens total_tokens total_cost tags tracked_at].freeze
-    FEATURE_COLUMNS = {
+    COLUMN_GENERATORS = {
+      "event_id" => "bin/rails generate llm_cost_tracker:add_ingestion",
       "latency_ms" => "bin/rails generate llm_cost_tracker:add_latency_ms",
       "stream" => "bin/rails generate llm_cost_tracker:add_streaming",
       "usage_source" => "bin/rails generate llm_cost_tracker:add_streaming",
-      "provider_response_id" => "bin/rails generate llm_cost_tracker:add_provider_response_id",
-      "cache_read_input_tokens" => "bin/rails generate llm_cost_tracker:add_usage_breakdown",
-      "cache_write_input_tokens" => "bin/rails generate llm_cost_tracker:add_usage_breakdown",
-      "hidden_output_tokens" => "bin/rails generate llm_cost_tracker:add_usage_breakdown",
-      "pricing_mode" => "bin/rails generate llm_cost_tracker:add_usage_breakdown"
-    }.freeze
+      "provider_response_id" => "bin/rails generate llm_cost_tracker:add_provider_response_id"
+    }.merge(
+      Generators::AddTokenUsageGenerator::COLUMN_NAMES.to_h do |column|
+        [column, "bin/rails generate llm_cost_tracker:add_token_usage"]
+      end
+    ).freeze
 
     class << self
-      def call = new.checks
+      def call
+        new.checks
+      end
 
       def report(checks = call)
-        (["LLM Cost Tracker doctor"] + checks.map { |check| format_check(check) }).join("\n")
+        (["LLM Cost Tracker doctor"] + 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
-
-      private
-
-      def format_check(check)
-        "[#{check.status}] #{check.name}: #{check.message}"
-      end
     end
 
     def checks
@@ -46,8 +45,8 @@ module LlmCostTracker
         table_check,
         column_check,
         period_totals_check,
-        IngestionCheck.call(Check),
-        prices_check,
+        IngestionCheck.new.call,
+        PriceCheck.new.call,
         calls_check
       ].compact
     end
@@ -56,10 +55,29 @@ module LlmCostTracker
 
     def configuration_check
       config = LlmCostTracker.configuration
-      Check.new(:ok, "configuration", "storage_backend=#{config.storage_backend.inspect}, enabled=#{config.enabled}")
+      Check.new(:ok, "configuration", "active_record ledger enabled=#{config.enabled}")
     end
 
-    def capture_check = CaptureCheck.call(Check)
+    def capture_check
+      config = LlmCostTracker.configuration
+      unless config.enabled
+        return Check.new(:warn, "capture", "tracking is disabled; set config.enabled = true to record calls")
+      end
+
+      if config.instrumented_integrations.any?
+        return Check.new(
+          :ok,
+          "capture",
+          "SDK integrations enabled: #{config.instrumented_integrations.join(', ')}"
+        )
+      end
+
+      Check.new(
+        :ok,
+        "capture",
+        "no SDK integrations enabled; Faraday middleware and manual capture remain available"
+      )
+    end
 
     def integration_checks
       LlmCostTracker::Integrations.checks.map do |check|
@@ -68,14 +86,13 @@ module LlmCostTracker
     end
 
     def active_record_check
-      return Check.new(:ok, "storage", "ActiveRecord storage is disabled") unless active_record_storage?
       return Check.new(:ok, "active_record", "available") if active_record_available?
 
-      Check.new(:error, "active_record", "unavailable; add ActiveRecord/Rails or change storage_backend")
+      Check.new(:error, "active_record", "unavailable")
     end
 
     def table_check
-      return unless active_record_storage? && active_record_available?
+      return unless active_record_available?
       return Check.new(:ok, "llm_api_calls", "table exists") if llm_api_calls_table?
 
       Check.new(
@@ -86,67 +103,45 @@ module LlmCostTracker
     end
 
     def column_check
-      return unless active_record_storage? && llm_api_calls_table?
+      return unless llm_api_calls_table?
 
-      columns = column_names("llm_api_calls")
-      missing_core = CORE_COLUMNS - columns
-      missing_features = FEATURE_COLUMNS.keys - columns
-      if missing_core.any?
-        return Check.new(:error, "llm_api_calls columns", "missing core columns: #{missing_core.join(', ')}")
-      end
-      if missing_features.any?
-        return Check.new(
-          :warn,
-          "llm_api_calls columns",
-          "missing optional columns; run #{feature_generators(missing_features).join(' && ')}"
-        )
-      end
+      errors = LlmCostTracker::Ledger::Schema::Calls.current_schema_errors
+      return Check.new(:ok, "llm_api_calls columns", "current") if errors.empty?
+
+      missing = LlmCostTracker::Ledger::Schema::Calls.missing_current_schema_columns
+      generators = missing.filter_map { |column| COLUMN_GENERATORS[column] }.uniq
+      message = "current schema required; #{errors.join('; ')}"
+      message = "#{message}; run #{generators.join(' && ')} && bin/rails db:migrate" if generators.any?
 
-      Check.new(:ok, "llm_api_calls columns", "current")
+      Check.new(:error, "llm_api_calls columns", message)
     end
 
     def period_totals_check
-      return unless active_record_storage? && llm_api_calls_table?
-      if table_exists?("llm_cost_tracker_period_totals")
-        return Check.new(:ok, "period totals", "llm_cost_tracker_period_totals exists")
-      end
+      return unless llm_api_calls_table?
 
-      Check.new(:warn, "period totals", "missing; budget preflight falls back to llm_api_calls sums")
-    end
-
-    def prices_check
-      path = LlmCostTracker.configuration.prices_file
-      unless path
-        return Check.new(
-          :warn,
-          "prices",
-          "using bundled prices updated_at=#{builtin_prices_updated_at}; configure prices_file for production"
-        )
-      end
+      errors = LlmCostTracker::Ledger::Schema::PeriodTotals.current_schema_errors
+      return Check.new(:ok, "period totals", "llm_cost_tracker_period_totals exists") if errors.empty?
 
-      count = LlmCostTracker::PriceRegistry.file_prices(path).size
-      metadata = LlmCostTracker::PriceRegistry.file_metadata(path)
-      status, freshness = LlmCostTracker::PriceFreshness.call(metadata)
-      Check.new(status, "prices", "loaded #{count} models from #{path}; #{freshness}")
-    rescue LlmCostTracker::Error => e
-      Check.new(:error, "prices", e.message)
+      Check.new(
+        :error,
+        "period totals",
+        "current schema required; #{errors.join('; ')}; " \
+        "run bin/rails generate llm_cost_tracker:add_period_totals && bin/rails db:migrate"
+      )
     end
 
     def calls_check
-      return unless active_record_storage? && llm_api_calls_table?
+      return unless llm_api_calls_table?
 
-      count = LlmCostTracker::LlmApiCall.count
+      count = LlmCostTracker::Ledger::Call.count
       return Check.new(:warn, "tracked calls", "none recorded yet") if count.zero?
 
-      latest = LlmCostTracker::LlmApiCall.maximum(:tracked_at)&.utc&.iso8601
+      latest = LlmCostTracker::Ledger::Call.maximum(:tracked_at)&.utc&.iso8601
       Check.new(:ok, "tracked calls", "#{count} recorded; latest #{latest}")
     end
 
-    def active_record_storage? = LlmCostTracker.configuration.storage_backend == :active_record
-
     def active_record_available?
-      require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
-      LlmCostTracker::LlmApiCall.connection
+      LlmCostTracker::Ledger::Call.connection
       true
     rescue LoadError, StandardError
       false
@@ -157,17 +152,9 @@ module LlmCostTracker
     end
 
     def table_exists?(name)
-      LlmCostTracker::LlmApiCall.connection.data_source_exists?(name)
+      LlmCostTracker::Ledger::Call.connection.data_source_exists?(name)
     rescue StandardError
       false
     end
-
-    def column_names(table) = LlmCostTracker::LlmApiCall.connection.columns(table).map(&:name)
-
-    def feature_generators(columns) = columns.map { |column| FEATURE_COLUMNS.fetch(column) }.uniq
-
-    def builtin_prices_updated_at
-      LlmCostTracker::PriceRegistry.metadata.fetch("updated_at", "unknown")
-    end
   end
 end

data/lib/llm_cost_tracker/engine.rb

@@ -2,12 +2,9 @@
 
 require "rails"
 require_relative "../llm_cost_tracker"
-require_relative "engine_compatibility"
 require_relative "assets"
 require "rack/files"
 
-LlmCostTracker::EngineCompatibility.check_rails_version!(Rails.version)
-
 module LlmCostTracker
   class Engine < ::Rails::Engine
     isolate_namespace LlmCostTracker

data/lib/llm_cost_tracker/errors.rb

@@ -18,7 +18,10 @@ module LlmCostTracker
       @budget_type = budget_type || inferred_budget_type
       @last_event = last_event
 
-      super("LLM #{budget_label} budget exceeded: $#{format('%.6f', @total)} / $#{format('%.6f', budget)}")
+      super(
+        "LLM #{@budget_type.to_s.tr('_', '-')} budget exceeded: " \
+        "$#{format('%.6f', @total)} / $#{format('%.6f', budget)}"
+      )
     end
 
     private
@@ -30,10 +33,6 @@ module LlmCostTracker
 
       :unknown
     end
-
-    def budget_label
-      budget_type.to_s.tr("_", "-")
-    end
   end
 
   class UnknownPricingError < Error
@@ -45,14 +44,4 @@ module LlmCostTracker
       super("No pricing configured for LLM model: #{model.inspect}")
     end
   end
-
-  class StorageError < Error
-    attr_reader :original_error
-
-    def initialize(original_error)
-      @original_error = original_error
-
-      super("Failed to store LLM cost event: #{original_error.class}: #{original_error.message}")
-    end
-  end
 end

data/lib/llm_cost_tracker/event.rb

@@ -5,12 +5,7 @@ module LlmCostTracker
     :event_id,
     :provider,
     :model,
-    :input_tokens,
-    :output_tokens,
-    :total_tokens,
-    :cache_read_input_tokens,
-    :cache_write_input_tokens,
-    :hidden_output_tokens,
+    :token_usage,
     :pricing_mode,
     :cost,
     :tags,
@@ -20,8 +15,13 @@ module LlmCostTracker
     :provider_response_id,
     :tracked_at
   ) do
+    def total_cost
+      cost&.fetch(:total_cost, nil)
+    end
+
     def to_h
       super.merge(
+        token_usage: token_usage.to_h,
         cost: cost&.to_h,
         tags: tags ? tags.to_h : {}
       )

data/lib/llm_cost_tracker/generators/llm_cost_tracker/add_token_usage_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class AddTokenUsageGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      TOKEN_COLUMNS = %w[
+        cache_read_input_tokens
+        cache_write_input_tokens
+        cache_write_1h_input_tokens
+        hidden_output_tokens
+      ].freeze
+      COST_COLUMNS = %w[
+        cache_read_input_cost
+        cache_write_input_cost
+        cache_write_1h_input_cost
+      ].freeze
+      COLUMN_NAMES = (TOKEN_COLUMNS + COST_COLUMNS + %w[pricing_mode]).freeze
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a migration to add token usage and token cost columns to llm_api_calls"
+
+      def create_migration_file
+        migration_template(
+          "add_token_usage_to_llm_api_calls.rb.erb",
+          "db/migrate/add_token_usage_to_llm_api_calls.rb"
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/install_generator.rb

@@ -2,6 +2,8 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
+require "llm_cost_tracker/pricing"
+require "llm_cost_tracker/token_usage"
 
 module LlmCostTracker
   module Generators

data/lib/llm_cost_tracker/generators/llm_cost_tracker/prices_generator.rb

@@ -2,9 +2,9 @@
 
 require "rails/generators"
 
-require_relative "../../price_registry"
-require_relative "../../price_sync/registry_loader"
-require_relative "../../price_sync/registry_writer"
+require_relative "../../pricing/registry"
+require_relative "../../pricing/sync/registry_loader"
+require_relative "../../pricing/sync/registry_writer"
 
 module LlmCostTracker
   module Generators
@@ -12,11 +12,11 @@ module LlmCostTracker
       desc "Creates a local LLM Cost Tracker price snapshot"
 
       def create_prices_file
-        registry = LlmCostTracker::PriceSync::RegistryLoader.new.call(
-          path: LlmCostTracker::PriceRegistry::DEFAULT_PRICES_PATH,
-          seed_path: LlmCostTracker::PriceRegistry::DEFAULT_PRICES_PATH
+        registry = LlmCostTracker::Pricing::Sync::RegistryLoader.new.call(
+          path: LlmCostTracker::Pricing::Registry::DEFAULT_PRICES_PATH,
+          seed_path: LlmCostTracker::Pricing::Registry::DEFAULT_PRICES_PATH
         )
-        LlmCostTracker::PriceSync::RegistryWriter.new.call(
+        LlmCostTracker::Pricing::Sync::RegistryWriter.new.call(
           path: File.join(destination_root, "config/llm_cost_tracker_prices.yml"),
           registry: registry
         )

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_period_totals_to_llm_cost_tracker.rb.erb

@@ -1,4 +1,4 @@
-require "llm_cost_tracker/active_record_adapter"
+require "llm_cost_tracker/ledger/schema/adapter"
 
 class AddPeriodTotalsToLlmCostTracker < ActiveRecord::Migration<%= migration_version %>
   def up
@@ -80,7 +80,7 @@ class AddPeriodTotalsToLlmCostTracker < ActiveRecord::Migration<%= migration_ver
     elsif mysql?
       "DATE(tracked_at)"
     else
-      "date(tracked_at)"
+      raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
     end
   end
 
@@ -90,15 +90,15 @@ class AddPeriodTotalsToLlmCostTracker < ActiveRecord::Migration<%= migration_ver
     elsif mysql?
       "DATE_FORMAT(tracked_at, '%Y-%m-01')"
     else
-      "strftime('%Y-%m-01', tracked_at)"
+      raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
     end
   end
 
   def postgresql?
-    LlmCostTracker::ActiveRecordAdapter.postgresql?(connection)
+    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
   end
 
   def mysql?
-    LlmCostTracker::ActiveRecordAdapter.mysql?(connection)
+    LlmCostTracker::Ledger::Schema::Adapter.mysql?(connection)
   end
 end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_token_usage_to_llm_api_calls.rb.erb

@@ -0,0 +1,22 @@
+class AddTokenUsageToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
+  def up
+<% LlmCostTracker::Generators::AddTokenUsageGenerator::TOKEN_COLUMNS.each do |column| -%>
+    unless column_exists?(:llm_api_calls, :<%= column %>)
+      add_column :llm_api_calls, :<%= column %>, :integer, null: false, default: 0
+    end
+<% end -%>
+<% LlmCostTracker::Generators::AddTokenUsageGenerator::COST_COLUMNS.each do |column| -%>
+    unless column_exists?(:llm_api_calls, :<%= column %>)
+      add_column :llm_api_calls, :<%= column %>, :decimal, precision: 20, scale: 8
+    end
+<% end -%>
+    add_column :llm_api_calls, :pricing_mode, :string unless column_exists?(:llm_api_calls, :pricing_mode)
+  end
+
+  def down
+    remove_column :llm_api_calls, :pricing_mode if column_exists?(:llm_api_calls, :pricing_mode)
+<% (LlmCostTracker::Generators::AddTokenUsageGenerator::COST_COLUMNS + LlmCostTracker::Generators::AddTokenUsageGenerator::TOKEN_COLUMNS).reverse.each do |column| -%>
+    remove_column :llm_api_calls, :<%= column %> if column_exists?(:llm_api_calls, :<%= column %>)
+<% end -%>
+  end
+end