active_genie 0.26.0 → 0.26.6

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
@@ -41,9 +38,16 @@ module ActiveGenie
       private
 
       def matches
+        match_keys = {}
+
         @relegation_tier.each_with_object([]) do |attack_player, matches|
           BATTLE_PER_PLAYER.times do
-            matches << [attack_player, next_defense_player].shuffle
+            defense_player = next_defense_player
+
+            next if match_keys["#{attack_player.id}_#{defense_player.id}"]
+
+            match_keys["#{attack_player.id}_#{defense_player.id}"] = true
+            matches << [attack_player, defense_player]
           end
         end
       end
@@ -55,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)
@@ -87,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
@@ -111,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

@@ -27,13 +27,7 @@ module ActiveGenie
       end
 
       def elo
-        @elo = if @params[:elo]
-                 @params[:elo]
-               elsif @score
-                 generate_elo_by_score
-               else
-                 BASE_ELO
-               end
+        @elo = @elo || @params[:elo] || generate_elo_by_score
       end
 
       def ffa_win_count
@@ -53,38 +47,30 @@ 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
-        (@ffa_win_count * 3) + @ffa_draw_count
+        (ffa_win_count * 3) + ffa_draw_count
       end
 
       def sort_value
@@ -127,7 +113,9 @@ module ActiveGenie
       private
 
       def generate_elo_by_score
-        BASE_ELO + ((@score || 0) - 50)
+        return BASE_ELO if @score.nil?
+
+        BASE_ELO + (@score - 50)
       end
     end
   end

data/lib/active_genie/ranking/players_collection.rb

@@ -56,7 +56,7 @@ module ActiveGenie
       end
 
       def to_json(*_args)
-        to_h.to_json
+        @players.map(&:to_h).to_json
       end
 
       def method_missing(...)
@@ -84,7 +84,11 @@ module ActiveGenie
       def tier_size
         size = (eligible_size / 3).ceil
 
-        size.clamp(10, eligible_size - 10)
+        if eligible_size < 10
+          (eligible_size / 2).ceil
+        else
+          size.clamp(10, eligible_size - 10)
+        end
       end
     end
   end

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,14 +52,14 @@ 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

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.26.6
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-02 00:00:00.000000000 Z
+date: 2025-06-09 00:00:00.000000000 Z
 dependencies: []
 description: |
   The lodash for GenAI, stop reinventing the wheel
@@ -35,6 +35,7 @@ files:
 - lib/active_genie/clients/providers/google_client.rb
 - lib/active_genie/clients/providers/openai_client.rb
 - lib/active_genie/clients/unified_client.rb
+- lib/active_genie/config/README.md
 - lib/active_genie/config/battle_config.rb
 - lib/active_genie/config/data_extractor_config.rb
 - lib/active_genie/config/llm_config.rb
@@ -60,7 +61,6 @@ files:
 - 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