lex-finops 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f9cb0d0ed46a270344440e8f344fc319957c74d9d0aae5144e4a0182cb36d063
+  data.tar.gz: 5aeba9c49abbe8e184da089e1e74f73aa9ba69ccb7e65b47847f3e088c3b1df4
+SHA512:
+  metadata.gz: 2d7098c01e6135acc49c7c1f6570d91f1bd750f66e859aee47bc89874b42a4af72d87d921ce0bb8e1b9c49c9a8fc725c01d32b00cb9756cd2adb2e7450f8d172
+  data.tar.gz: 449a3a43392919cce61d9e7033b9a1ef362353ffda0ef71679549771cdb0a98c63e52b97829b41af1efeab5202c940c23760affa2153082a53130255b0e1c97e

data/lib/legion/extensions/finops/helpers/budget_store.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Finops
+      module Helpers
+        module BudgetStore
+          BudgetEntry = Struct.new(:entity_type, :entity_id, :period_key, :limit_usd,
+                                   :spent_usd, :hard_stop, :alerts_sent)
+
+          ALERT_THRESHOLDS = [50, 75, 90, 100].freeze
+
+          @mutex = Mutex.new
+          @budgets = {}
+
+          module_function
+
+          def set_budget(entity_type:, entity_id:, limit_usd:, period_key:, hard_stop: false)
+            key = budget_key(entity_type, entity_id, period_key)
+            @mutex.synchronize do
+              @budgets[key] = BudgetEntry.new(
+                entity_type: entity_type, entity_id: entity_id, period_key: period_key,
+                limit_usd: limit_usd, spent_usd: 0.0, hard_stop: hard_stop, alerts_sent: Set.new
+              )
+            end
+          end
+
+          def record_spend(entity_type:, entity_id:, period_key:, amount_usd:)
+            key = budget_key(entity_type, entity_id, period_key)
+            alerts = []
+            @mutex.synchronize do
+              entry = @budgets[key]
+              return { recorded: false, reason: :no_budget } unless entry
+
+              entry.spent_usd += amount_usd
+              alerts = check_thresholds(entry)
+            end
+            { recorded: true, alerts: alerts }
+          end
+
+          def check_budget(entity_type:, entity_id:, period_key:, estimated_cost: 0)
+            key = budget_key(entity_type, entity_id, period_key)
+            @mutex.synchronize do
+              entry = @budgets[key]
+              return { allowed: true, reason: :no_budget } unless entry
+
+              remaining = [entry.limit_usd - entry.spent_usd, 0].max
+              pct = ((entry.spent_usd + estimated_cost) / entry.limit_usd * 100).round(1)
+              if pct >= 100 && entry.hard_stop
+                { allowed: false, reason: :hard_stop, percent_used: pct, remaining_usd: remaining }
+              else
+                { allowed: true, percent_used: pct, remaining_usd: remaining }
+              end
+            end
+          end
+
+          def status(entity_type:, entity_id:, period_key:)
+            key = budget_key(entity_type, entity_id, period_key)
+            @mutex.synchronize { @budgets[key]&.to_h }
+          end
+
+          def clear_all
+            @mutex.synchronize { @budgets.clear }
+          end
+
+          def check_thresholds(entry)
+            pct = (entry.spent_usd / entry.limit_usd * 100).round(1)
+            alerts = []
+            ALERT_THRESHOLDS.each do |t|
+              threshold_sym = :"t#{t}"
+              next unless pct >= t && !entry.alerts_sent.include?(threshold_sym)
+
+              entry.alerts_sent.add(threshold_sym)
+              alerts << { threshold: t, percent_used: pct,
+                          entity_type: entry.entity_type, entity_id: entry.entity_id }
+            end
+            alerts
+          end
+          private_class_method :check_thresholds
+
+          def budget_key(entity_type, entity_id, period_key)
+            "#{entity_type}:#{entity_id}:#{period_key}"
+          end
+          private_class_method :budget_key
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/finops/helpers/cost_calculator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Finops
+      module Helpers
+        module CostCalculator
+          DEFAULT_RATES = { input_per_1k: 0.005, output_per_1k: 0.015, thinking_per_1k: 0.005 }.freeze
+
+          module_function
+
+          def estimate_cost(provider:, model:, input_tokens:, output_tokens:, thinking_tokens: 0)
+            rates = pricing_for(provider, model)
+            (input_tokens * rates[:input_per_1k] / 1000.0) +
+              (output_tokens * rates[:output_per_1k] / 1000.0) +
+              (thinking_tokens * rates[:thinking_per_1k] / 1000.0)
+          end
+
+          def pricing_for(provider, model)
+            finops = finops_settings
+            pricing = finops[:pricing]
+            return DEFAULT_RATES unless pricing.is_a?(Hash)
+
+            provider_pricing = pricing[provider.to_sym]
+            return DEFAULT_RATES unless provider_pricing.is_a?(Hash)
+
+            model_pricing = provider_pricing[model.to_s] || provider_pricing[:default]
+            return model_pricing.transform_keys(&:to_sym) if model_pricing.is_a?(Hash)
+
+            DEFAULT_RATES
+          end
+
+          def finops_settings
+            settings = Legion::Settings[:finops]
+            settings.is_a?(Hash) ? settings : {}
+          rescue StandardError
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/finops/runners/budget.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Finops
+      module Runners
+        module Budget
+          def check_budget(worker_id:, tenant_id: nil, estimated_cost: 0, **)
+            period_key = Time.now.utc.strftime('%Y-%m')
+            results = []
+            results << Helpers::BudgetStore.check_budget(
+              entity_type: :worker, entity_id: worker_id,
+              period_key: period_key, estimated_cost: estimated_cost
+            )
+            if tenant_id
+              results << Helpers::BudgetStore.check_budget(
+                entity_type: :tenant, entity_id: tenant_id,
+                period_key: period_key, estimated_cost: estimated_cost
+              )
+            end
+            blocked = results.find { |r| !r[:allowed] }
+            blocked || { allowed: true }
+          end
+
+          def record_spend(worker_id:, cost_usd:, tenant_id: nil, team: nil, **)
+            period_key = Time.now.utc.strftime('%Y-%m')
+            all_alerts = []
+            [[:worker, worker_id], [:tenant, tenant_id], [:team, team]].each do |type, id|
+              next unless id
+
+              result = Helpers::BudgetStore.record_spend(
+                entity_type: type, entity_id: id,
+                period_key: period_key, amount_usd: cost_usd
+              )
+              all_alerts.concat(result[:alerts]) if result[:alerts]
+            end
+            emit_budget_alerts(all_alerts) unless all_alerts.empty?
+            { recorded: true, alerts_fired: all_alerts.size }
+          end
+
+          def set_budget(entity_type:, entity_id:, limit_usd:, hard_stop: false, **)
+            period_key = Time.now.utc.strftime('%Y-%m')
+            Helpers::BudgetStore.set_budget(
+              entity_type: entity_type, entity_id: entity_id,
+              limit_usd: limit_usd, period_key: period_key, hard_stop: hard_stop
+            )
+            { set: true, entity_type: entity_type, entity_id: entity_id, limit_usd: limit_usd }
+          end
+
+          def budget_status(entity_type:, entity_id:, **)
+            period_key = Time.now.utc.strftime('%Y-%m')
+            Helpers::BudgetStore.status(entity_type: entity_type, entity_id: entity_id, period_key: period_key)
+          end
+
+          private
+
+          def emit_budget_alerts(alerts)
+            return unless defined?(Legion::Events)
+
+            alerts.each do |alert|
+              Legion::Events.emit('finops.budget_alert', alert)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/finops/runners/cost_attribution.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Finops
+      module Runners
+        module CostAttribution
+          def attribute_cost(worker_id:, provider:, model:, input_tokens:,
+                             output_tokens:, tenant_id: nil, team: nil,
+                             task_id: nil, extension: nil, thinking_tokens: 0, **)
+            cost = Helpers::CostCalculator.estimate_cost(
+              provider: provider, model: model,
+              input_tokens: input_tokens, output_tokens: output_tokens,
+              thinking_tokens: thinking_tokens
+            )
+
+            record = {
+              worker_id: worker_id, tenant_id: tenant_id, team: team,
+              task_id: task_id, extension: extension,
+              provider: provider, model: model,
+              input_tokens: input_tokens, output_tokens: output_tokens,
+              thinking_tokens: thinking_tokens,
+              cost_usd: cost, attributed_at: Time.now.utc.iso8601
+            }
+
+            emit_attribution(record) if defined?(Legion::Events)
+            record
+          end
+
+          SUMMARY_COLUMNS = %i[worker_id provider model_id].freeze
+
+          def cost_summary(group_by: :worker_id, since: nil, limit: 20, **)
+            return { error: 'data_unavailable' } unless metering_available?
+
+            col = SUMMARY_COLUMNS.include?(group_by.to_sym) ? group_by.to_sym : :worker_id
+            rows = aggregate_metering(col, since: since, limit: limit)
+            { group_by: col, rows: rows, count: rows.size }
+          end
+
+          private
+
+          def aggregate_metering(col, since:, limit:)
+            ds = Legion::Data.connection[:metering_records]
+            ds = ds.where { recorded_at >= since } if since
+            ds.group_and_count(col)
+              .select_append { sum(input_tokens).as(total_input) }
+              .select_append { sum(output_tokens).as(total_output) }
+              .select_append { sum(total_tokens).as(total_tokens) }
+              .order(Sequel.desc(:count))
+              .limit(limit)
+              .all
+          end
+
+          def metering_available?
+            defined?(Legion::Data) && Legion::Data.respond_to?(:connection) &&
+              Legion::Data.connection&.table_exists?(:metering_records)
+          rescue StandardError
+            false
+          end
+
+          def emit_attribution(record)
+            Legion::Events.emit('finops.cost_attributed', record)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/finops/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Finops
+      VERSION = '0.1.2'
+    end
+  end
+end

data/lib/legion/extensions/finops.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'finops/version'
+
+module Legion
+  module Extensions
+    module Finops
+    end
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: lex-finops
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+description: Budget enforcement, cost attribution, and FinOps reporting for LegionIO
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/finops.rb
+- lib/legion/extensions/finops/helpers/budget_store.rb
+- lib/legion/extensions/finops/helpers/cost_calculator.rb
+- lib/legion/extensions/finops/runners/budget.rb
+- lib/legion/extensions/finops/runners/cost_attribution.rb
+- lib/legion/extensions/finops/version.rb
+homepage: https://github.com/LegionIO
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX::Finops
+test_files: []