active_genie 0.26.5 → 0.27.1

data/lib/active_genie/logger.rb

@@ -4,47 +4,65 @@ require 'json'
 require 'fileutils'
 
 module ActiveGenie
-  module Logger
-    module_function
+  class Logger
+    def initialize(log_config: nil)
+      @log_config = log_config || ActiveGenie.configuration.log
+    end
 
     def call(data)
-      log = {
-        **(@context || {}),
-        **(data || {}),
-        timestamp: Time.now,
-        process_id: Process.pid
-      }
+      log = data.merge(@log_config.additional_context)
+                .merge(
+                  timestamp: Time.now,
+                  process_id: Process.pid
+                )
 
       persist!(log)
-      config.output_call(log)
+      output_call(log)
+      call_observers(log)
 
       log
     end
 
-    def with_context(context, observer: nil)
-      @context ||= {}
-      begin
-        @context = @context.merge(context)
-        config.add_observer(observers: [observer])
-        yield if block_given?
-      ensure
-        @context.delete_if { |key, _| context.key?(key) }
-        config.remove_observer([observer])
+    def merge(log_config = nil)
+      new(log_config:)
+    end
+
+    private
+
+    def call_observers(log)
+      Array(@log_config.observers).each do |observer|
+        next unless observer[:scope].all? { |key, value| log[key.to_sym] == value }
+
+        observer[:observer]&.call(log)
+      rescue StandardError => e
+        call(code: :observer_error, **observer, error: e.message)
       end
     end
 
-    attr_accessor :context
+    def output_call(log)
+      if @log_config.output
+        @log_config.output&.call(log)
+      else
+        $stdout.puts log
+      end
+    rescue StandardError => e
+      call(code: :output_error, error: e.message)
+    end
 
     def persist!(log)
-      file_path = log.key?(:fine_tune) && log[:fine_tune] ? config.fine_tune_file_path : config.file_path
+      file_path = log_to_file_path(log)
       folder_path = File.dirname(file_path)
 
       FileUtils.mkdir_p(folder_path)
       File.write(file_path, "#{JSON.generate(log)}\n", mode: 'a')
     end
 
-    def config
-      ActiveGenie.configuration.log
+    def log_to_file_path(log)
+      if log.key?(:fine_tune) && log[:fine_tune]
+        @log_config.fine_tune_file_path
+      else
+        @log_config.file_path
+      end
     end
   end
 end

data/lib/active_genie/ranking/elo_round.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../battle/generalist'
-
 module ActiveGenie
   module Ranking
     class EloRound
@@ -9,27 +7,26 @@ module ActiveGenie
         new(...).call
       end
 
-      def initialize(players, criteria, config: {})
+      def initialize(players, criteria, config: nil)
         @players = players
         @relegation_tier = players.calc_relegation_tier
         @defender_tier = players.calc_defender_tier
         @criteria = criteria
-        @config = config
+        @config = ActiveGenie.configuration.merge(config)
         @tmp_defenders = []
         @total_tokens = 0
-        @previous_elo = {}
+        @previous_elo = @players.to_h { |player| [player.id, player.elo] }
         @previous_highest_elo = @defender_tier.max_by(&:elo).elo
       end
 
       def call
-        @previous_elo = @players.to_h { |player| [player.id, player.elo] }
+        @config.log.add_observer(observers: ->(log) { log_observer(log) })
+        @config.log.additional_context = { elo_round_id: }
 
-        ActiveGenie::Logger.with_context(log_context) do
-          matches.each do |player_a, player_b|
-            # TODO: battle can take a while, can be parallelized
-            winner, loser = battle(player_a, player_b)
-            update_players_elo(winner, loser)
-          end
+        matches.each do |player_a, player_b|
+          # TODO: battle can take a while, can be parallelized
+          winner, loser = battle(player_a, player_b)
+          update_players_elo(winner, loser)
         end
 
         build_report
@@ -62,22 +59,20 @@ module ActiveGenie
       end
 
       def battle(player_a, player_b)
-        ActiveGenie::Logger.with_context({ player_a_id: player_a.id, player_b_id: player_b.id }) do
-          result = ActiveGenie::Battle.call(
-            player_a.content,
-            player_b.content,
-            @criteria,
-            config: @config
-          )
-
-          winner, loser = case result['winner']
-                          when 'player_a' then [player_a, player_b]
-                          when 'player_b' then [player_b, player_a]
-                          when 'draw' then [nil, nil]
-                          end
-
-          [winner, loser]
-        end
+        result = ActiveGenie::Battle.call(
+          player_a.content,
+          player_b.content,
+          @criteria,
+          config: @config.merge(additional_context: { player_a_id: player_a.id, player_b_id: player_b.id })
+        )
+
+        winner, loser = case result['winner']
+                        when 'player_a' then [player_a, player_b]
+                        when 'player_b' then [player_b, player_a]
+                        when 'draw' then [nil, nil]
+                        end
+
+        [winner, loser]
       end
 
       def update_players_elo(winner, loser)
@@ -94,16 +89,14 @@ module ActiveGenie
         player_rating + (K * (score - expected_score)).round
       end
 
-      def log_context
-        { elo_round_id: }
-      end
-
       def elo_round_id
-        relegation_tier_ids = @relegation_tier.map(&:id).join(',')
-        defender_tier_ids = @defender_tier.map(&:id).join(',')
+        @elo_round_id ||= begin
+          relegation_tier_ids = @relegation_tier.map(&:id).join(',')
+          defender_tier_ids = @defender_tier.map(&:id).join(',')
 
-        ranking_unique_key = [relegation_tier_ids, defender_tier_ids, @criteria, @config.to_json].join('-')
-        Digest::MD5.hexdigest(ranking_unique_key)
+          ranking_unique_key = [relegation_tier_ids, defender_tier_ids, @criteria, @config.to_json].join('-')
+          Digest::MD5.hexdigest(ranking_unique_key)
+        end
       end
 
       def build_report
@@ -118,7 +111,7 @@ module ActiveGenie
           players_elo_diff:
         }
 
-        ActiveGenie::Logger.call({ code: :elo_round_report, **report })
+        @config.logger.call({ elo_round_id:, code: :elo_round_report, **report })
 
         report
       end

data/lib/active_genie/ranking/free_for_all.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../battle/generalist'
-
 module ActiveGenie
   module Ranking
     class FreeForAll
@@ -9,21 +7,22 @@ module ActiveGenie
         new(...).call
       end
 
-      def initialize(players, criteria, config: {})
+      def initialize(players, criteria, config: nil)
         @players = players
         @criteria = criteria
-        @config = config
+        @config = config || ActiveGenie.configuration
         @start_time = Time.now
         @total_tokens = 0
       end
 
       def call
-        ActiveGenie::Logger.with_context(log_context, observer: ->(log) { log_observer(log) }) do
-          matches.each do |player_a, player_b|
-            winner, loser = battle(player_a, player_b)
+        @config.log.add_observer(observers: ->(log) { log_observer(log) })
+        @config.log.additional_context = { free_for_all_id: }
+
+        matches.each do |player_a, player_b|
+          winner, loser = battle(player_a, player_b)
 
-            update_players_score(winner, loser)
-          end
+          update_players_score(winner, loser)
         end
 
         build_report
@@ -38,26 +37,30 @@ module ActiveGenie
       end
 
       def battle(player_a, player_b)
+        log_context = { player_a_id: player_a.id, player_b_id: player_b.id }
+
         result = ActiveGenie::Battle.call(
           player_a.content,
           player_b.content,
           @criteria,
-          config: @config
+          config: @config.merge(additional_context: log_context)
         )
 
         winner, loser = case result['winner']
-                        when 'player_a' then [player_a, player_b, result['reasoning']]
-                        when 'player_b' then [player_b, player_a, result['reasoning']]
-                        when 'draw' then [nil, nil, result['reasoning']]
+                        when 'player_a' then [player_a, player_b]
+                        when 'player_b' then [player_b, player_a]
+                        when 'draw' then [nil, nil]
                         end
 
-        ActiveGenie::Logger.call({
-                                   code: :free_for_all_battle,
-                                   player_ids: [player_a.id, player_b.id],
-                                   winner_id: winner&.id,
-                                   loser_id: loser&.id,
-                                   reasoning: result['reasoning']
-                                 })
+        @config.logger.call(
+          {
+            **log_context,
+            code: :free_for_all_battle,
+            winner_id: winner&.id,
+            loser_id: loser&.id,
+            reasoning: result['reasoning']
+          }
+        )
 
         [winner, loser]
       end
@@ -74,14 +77,12 @@ module ActiveGenie
         end
       end
 
-      def log_context
-        { free_for_all_id: }
-      end
-
       def free_for_all_id
-        eligible_ids = @players.eligible.map(&:id).join(',')
-        ranking_unique_key = [eligible_ids, @criteria, @config.to_json].join('-')
-        Digest::MD5.hexdigest(ranking_unique_key)
+        @free_for_all_id ||= begin
+          eligible_ids = @players.eligible.map(&:id).join(',')
+          ranking_unique_key = [eligible_ids, @criteria, @config.to_json].join('-')
+          Digest::MD5.hexdigest(ranking_unique_key)
+        end
       end
 
       def build_report
@@ -92,7 +93,7 @@ module ActiveGenie
           total_tokens: @total_tokens
         }
 
-        ActiveGenie::Logger.call({ code: :free_for_all_report, **report })
+        @config.logger.call({ code: :free_for_all_report, **report })
 
         report
       end

data/lib/active_genie/ranking/player.rb

@@ -47,34 +47,26 @@ module ActiveGenie
       end
 
       def score=(value)
-        ActiveGenie::Logger.call({ code: :new_score, player_id: id, score: value }) if value != @score
         @score = value
         @elo = generate_elo_by_score
       end
 
       def elo=(value)
-        ActiveGenie::Logger.call({ code: :new_elo, player_id: id, elo: value }) if value != @elo
         @elo = value || BASE_ELO
       end
 
-      def eliminated=(value)
-        ActiveGenie::Logger.call({ code: :new_eliminated, player_id: id, eliminated: value }) if value != @eliminated
-        @eliminated = value
-      end
+      attr_writer :eliminated
 
       def draw!
         @ffa_draw_count += 1
-        ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'draw', ffa_score: })
       end
 
       def win!
         @ffa_win_count += 1
-        ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'win', ffa_score: })
       end
 
       def lose!
         @ffa_lose_count += 1
-        ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'lose', ffa_score: })
       end
 
       def ffa_score

data/lib/active_genie/ranking/ranking.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'concerns/loggable'
 require_relative 'players_collection'
 require_relative 'free_for_all'
 require_relative 'elo_round'
@@ -32,8 +31,6 @@ require_relative 'ranking_scoring'
 module ActiveGenie
   module Ranking
     class Ranking
-      include ActiveGenie::Concerns::Loggable
-
       def self.call(...)
         new(...).call
       end
@@ -48,20 +45,19 @@ module ActiveGenie
 
       def call
         @players = create_players
+        @config.log.additional_context = { ranking_id: }
 
-        ActiveGenie::Logger.with_context(log_context) do
-          set_initial_player_scores!
-          eliminate_obvious_bad_players!
-
-          while @players.elo_eligible?
-            elo_report = run_elo_round!
-            eliminate_relegation_players!
-            rebalance_players!(elo_report)
-          end
+        set_initial_player_scores!
+        eliminate_obvious_bad_players!
 
-          run_free_for_all!
+        while @players.elo_eligible?
+          elo_report = run_elo_round!
+          eliminate_relegation_players!
+          rebalance_players!(elo_report)
         end
 
+        run_free_for_all!
+
         sorted_players
       end
 
@@ -72,13 +68,18 @@ module ActiveGenie
 
       def create_players
         players = PlayersCollection.new(@param_players)
-        players.each { |p| ActiveGenie::Logger.call({ code: :new_player, player: p.to_h }) }
+        players.each { |p| @config.logger.call({ code: :new_player, player: p.to_h }) }
 
         players
       end
 
       def set_initial_player_scores!
-        RankingScoring.call(@players, @criteria, reviewers: @reviewers, config: @config)
+        RankingScoring.call(
+          @players,
+          @criteria,
+          reviewers: @reviewers,
+          config: @config
+        )
       end
 
       def eliminate_obvious_bad_players!
@@ -88,7 +89,11 @@ module ActiveGenie
       end
 
       def run_elo_round!
-        EloRound.call(@players, @criteria, config: @config)
+        EloRound.call(
+          @players,
+          @criteria,
+          config: @config
+        )
       end
 
       def eliminate_relegation_players!
@@ -106,25 +111,27 @@ module ActiveGenie
       end
 
       def run_free_for_all!
-        FreeForAll.call(@players, @criteria, config: @config)
+        FreeForAll.call(
+          @players,
+          @criteria,
+          config: @config
+        )
       end
 
       def sorted_players
         players = @players.sorted
-        ActiveGenie::Logger.call({ code: :ranking_final, players: players.map(&:to_h) })
+        @config.logger.call({ ranking_id:, code: :ranking_final, players: players.map(&:to_h) })
 
         players.map(&:to_h)
       end
 
-      def log_context
-        { ranking_id: }
-      end
-
       def ranking_id
-        player_ids = @players.map(&:id).join(',')
-        ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+        @ranking_id ||= begin
+          player_ids = @players.map(&:id).join(',')
+          ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
 
-        Digest::MD5.hexdigest(ranking_unique_key)
+          Digest::MD5.hexdigest(ranking_unique_key)
+        end
       end
     end
   end

data/lib/active_genie/ranking/ranking_scoring.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../scoring/recommended_reviewers'
-
 module ActiveGenie
   module Ranking
     class RankingScoring
@@ -9,7 +7,7 @@ module ActiveGenie
         new(...).call
       end
 
-      def initialize(players, criteria, reviewers: [], config: {})
+      def initialize(players, criteria, reviewers: [], config: nil)
         @players = players
         @criteria = criteria
         @config = ActiveGenie.configuration.merge(config)
@@ -17,12 +15,11 @@ module ActiveGenie
       end
 
       def call
-        ActiveGenie::Logger.with_context(log_context) do
-          @reviewers = generate_reviewers
+        @config.log.additional_context = { ranking_scoring_id: }
+        @reviewers = generate_reviewers
 
-          players_without_score.each do |player|
-            player.score = generate_score(player)
-          end
+        players_without_score.each do |player|
+          player.score = generate_score(player)
         end
       end
 
@@ -40,7 +37,7 @@ module ActiveGenie
           config: @config
         ).values_at('final_score', 'final_reasoning')
 
-        ActiveGenie::Logger.call({ code: :new_score, player_id: player.id, score:, reasoning: })
+        @config.logger.call({ code: :new_score, player_id: player.id, score:, reasoning: })
 
         score
       end
@@ -54,20 +51,18 @@ module ActiveGenie
           config: @config
         ).values_at('reviewer1', 'reviewer2', 'reviewer3')
 
-        ActiveGenie::Logger.call({ code: :new_reviewers, reviewers: [reviewer1, reviewer2, reviewer3] })
+        @config.logger.call({ code: :new_reviewers, reviewers: [reviewer1, reviewer2, reviewer3] })
 
         [reviewer1, reviewer2, reviewer3]
       end
 
-      def log_context
-        { ranking_scoring_id: }
-      end
-
       def ranking_scoring_id
-        player_ids = players_without_score.map(&:id).join(',')
-        ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+        @ranking_scoring_id ||= begin
+          player_ids = players_without_score.map(&:id).join(',')
+          ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
 
-        "#{Digest::MD5.hexdigest(ranking_unique_key)}-scoring"
+          "#{Digest::MD5.hexdigest(ranking_unique_key)}-scoring"
+        end
       end
     end
   end

data/lib/active_genie/scoring/generalist.rb

@@ -52,19 +52,19 @@ module ActiveGenie
 
         result['final_score'] = 0 if result['final_score'].nil?
 
-        ActiveGenie::Logger.call({
-                                   code: :scoring,
-                                   text: @text[0..30],
-                                   criteria: @criteria[0..30],
-                                   reviewers: reviewers,
-                                   score: result['final_score'],
-                                   reasoning: result['final_reasoning']
-                                 })
+        @config.logger.call({
+                              code: :scoring,
+                              text: @text[0..30],
+                              criteria: @criteria[0..30],
+                              reviewers: reviewers,
+                              score: result['final_score'],
+                              reasoning: result['final_reasoning']
+                            })
 
         result
       end
 
-      PROMPT = File.read(File.join(__dir__, 'generalist.md'))
+      PROMPT = File.read(File.join(__dir__, 'generalist.prompt.md'))
 
       private
 

data/lib/tasks/templates/active_genie.rb

@@ -7,7 +7,7 @@ ActiveGenie.configure do |config|
   # config.providers.openai.api_url = 'https://api.openai.com/v1'
   # config.providers.openai.lower_tier_model = 'gpt-4.1-mini'
   # config.providers.openai.middle_tier_model = 'gpt-4.1'
-  # config.providers.openai.upper_tier_model = 'o3-mini'
+  # config.providers.openai.higher_tier_model = 'o3-mini'
   # config.providers.openai.client = ActiveGenie::Providers::Openai::Client.new(config)
 
   # example how add a new provider

metadata

@@ -1,19 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.26.5
+  version: 0.27.1
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-03 00:00:00.000000000 Z
+date: 2025-06-30 00:00:00.000000000 Z
 dependencies: []
 description: |
-  The lodash for GenAI, stop reinventing the wheel
-
-  ActiveGenie is a Ruby gem that provides valuable solutions using GenAI. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules to reach real value fast and reliably. Backed by a custom benchmarking system that ensures consistent quality and performance across different models and providers in every release.
+  ActiveGenie is a Ruby gem that helps developers build reliable, future-proof GenAI features without worrying about changing models, prompts, or providers. Like Lodash for GenAI, it offers simple, reusable modules for tasks like data extraction, scoring, and ranking, so you can focus on your app’s logic, not the shifting AI landscape.
+  Behind the scenes, a custom benchmarking system keeps everything consistent across LLM vendors and versions, release after release.
 email:
 - radames@roriz.dev
 executables: []
@@ -27,7 +26,7 @@ files:
 - lib/active_genie/battle.rb
 - lib/active_genie/battle/README.md
 - lib/active_genie/battle/generalist.json
-- lib/active_genie/battle/generalist.md
+- lib/active_genie/battle/generalist.prompt.md
 - lib/active_genie/battle/generalist.rb
 - lib/active_genie/clients/providers/anthropic_client.rb
 - lib/active_genie/clients/providers/base_client.rb
@@ -49,18 +48,15 @@ files:
 - lib/active_genie/config/scoring_config.rb
 - lib/active_genie/configuration.rb
 - lib/active_genie/data_extractor.rb
-- lib/active_genie/data_extractor/README.md
 - lib/active_genie/data_extractor/from_informal.json
 - lib/active_genie/data_extractor/from_informal.rb
 - lib/active_genie/data_extractor/generalist.json
-- lib/active_genie/data_extractor/generalist.md
+- lib/active_genie/data_extractor/generalist.prompt.md
 - lib/active_genie/data_extractor/generalist.rb
 - lib/active_genie/errors/invalid_log_output_error.rb
 - lib/active_genie/errors/invalid_provider_error.rb
 - lib/active_genie/logger.rb
 - lib/active_genie/ranking.rb
-- lib/active_genie/ranking/README.md
-- lib/active_genie/ranking/concerns/loggable.rb
 - lib/active_genie/ranking/elo_round.rb
 - lib/active_genie/ranking/free_for_all.rb
 - lib/active_genie/ranking/player.rb
@@ -68,9 +64,8 @@ files:
 - lib/active_genie/ranking/ranking.rb
 - lib/active_genie/ranking/ranking_scoring.rb
 - lib/active_genie/scoring.rb
-- lib/active_genie/scoring/README.md
 - lib/active_genie/scoring/generalist.json
-- lib/active_genie/scoring/generalist.md
+- lib/active_genie/scoring/generalist.prompt.md
 - lib/active_genie/scoring/generalist.rb
 - lib/active_genie/scoring/recommended_reviewers.rb
 - lib/tasks/benchmark.rake
@@ -103,5 +98,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Transform your Ruby application with powerful, production-ready GenAI features
+summary: 'The Lodash for GenAI: Real Value + Consistent + Model-Agnostic'
 test_files: []