active_genie 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d0424a39ba21d821cb2419730387e1b026c35b5e2e5dff9f6d615f3ec54e6a3
-  data.tar.gz: 17b460ccd1a689d0f8709af2b84f3cde65aa0075b76104ee1b4bb8b3b0ffc182
+  metadata.gz: fbc4033f3c0880973cf732d704921bb61c3cb861c438b732aa6ebe0cc88b2de4
+  data.tar.gz: 11794293170ec43a1d3b3d09e5ec488351a22428a5370ae0e42266a6f8098646
 SHA512:
-  metadata.gz: ad98b2d5d063d0d1c4009e1a9f92d6d326ed948cbdee71317c94b6a4a0ee57042609c1f405ca7ce00d4beb321bc1e98ad722646349076929bcdc0a28da8b6b8b
-  data.tar.gz: d2cc39b77757619c5235041f12d5182778b4237444f3c2246982ebcf54c0542af0da194783cea57fbe4fbde0985ef635802c648796b4f5c4d7a5d4f42c6519c7
+  metadata.gz: f6b13b3f36a8e516e5126d4cea0de52d046e498834cd10b90b1905460e9bba5ff6e7c4cebd58e6ea2c073176566601c8b806015baa01f11f28792942eec6ca1d
+  data.tar.gz: fc79aed12aaba0ca335d3a7ef8405f4a7c2809de9d5e41ca14fa7bd843d9fb69db8e124b6a2e96321432575a58b271c724a52fd3c1a1165c5ecfe346bedd4b5f

data/README.md

@@ -1,16 +1,17 @@
 # ActiveGenie 🧞‍♂️
-> Transform your Ruby application with powerful, production-ready GenAI features
+> The lodash for GenAI, stop reinventing the wheel
 
 [![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)
 [![Ruby](https://github.com/roriz/active_genie/actions/workflows/ruby.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/ruby.yml)
 
-ActiveGenie is a Ruby gem that provides a polished, production-ready interface for working with Generative AI (GenAI) models. Just like ActiveStorage simplifies file handling in Rails, ActiveGenie makes it effortless to integrate GenAI capabilities into your Ruby applications.
+ActiveGenie is a Ruby gem that provides a polished, production-ready interface for working with Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie simplifies GenAI integration in your Ruby applications.
 
 ## Features
 
 - 🎯 **Data Extraction**: Extract structured data from unstructured text with type validation
-- 📊 **Smart Scoring**: Multi-reviewer evaluation system with automatic expert selection
-- 💭 **Leaderboard**: Consistent rank items based on custom criteria, using multiple tecniques of ranking
+- 📊 **Data Scoring**: Multi-reviewer evaluation system
+- ⚔️ **Data Battle**: Battle between two data like a political debate
+- 💭 **Data Ranking**: Consistent rank data using scoring + elo ranking + battles
 
 ## Installation
 
@@ -79,7 +80,7 @@ Features:
 
 See the [Data Extractor README](lib/active_genie/data_extractor/README.md) for informal text processing, advanced schemas, and detailed interface documentation.
 
-### Scoring
+### Data Scoring
 Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers. Get balanced scoring through AI-powered expert reviewers that automatically adapt to your content.
 
 ```ruby
@@ -104,7 +105,7 @@ Features:
 
 See the [Scoring README](lib/active_genie/scoring/README.md) for advanced usage, custom reviewers, and detailed interface documentation.
 
-### Battle
+### Data Battle
 AI-powered battle evaluation system that determines winners between two players based on specified criteria.
 
 ```ruby
@@ -132,8 +133,8 @@ Features:
 
 See the [Battle README](lib/active_genie/battle/README.md) for advanced usage, custom reviewers, and detailed interface documentation.
 
-### League
-The League module provides competitive ranking through multi-stage evaluation:
+### Data Ranking
+The Ranking module provides competitive ranking through multi-stage evaluation:
 
 
 ```ruby
@@ -142,7 +143,7 @@ require 'active_genie'
 players = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']
 criteria = "Best one to be used into a high changing environment"
 
-result = ActiveGenie::League.call(players, criteria)
+result = ActiveGenie::Ranking.call(players, criteria)
 # => {
 #      winner_player: "gRPC API",
 #      reasoning: "gRPC API is the best one to be used into a high changing environment",
@@ -153,51 +154,12 @@ result = ActiveGenie::League.call(players, criteria)
 - **Automatic elimination** of inconsistent performers using statistical analysis
 - **Dynamic ranking adjustments** based on simulated pairwise battles, from bottom to top
 
-See the [League README](lib/active_genie/league/README.md) for implementation details, configuration, and advanced ranking strategies.
+See the [Ranking README](lib/active_genie/ranking/README.md) for implementation details, configuration, and advanced ranking strategies.
 
-### Summarizer (WIP)
-The summarizer is a tool that can be used to summarize a given text. It uses a set of rules to summarize the text out of the box. Uses the best practices of prompt engineering and engineering to make the summarization as accurate as possible.
-
-```ruby
-require 'active_genie'
-
-text = "Example text to be summarized. The fox jumps over the dog"
-summarized_text = ActiveGenie::Summarizer.call(text)
-puts summarized_text # => "The fox jumps over the dog"
-```
-
-### Language detector (WIP)
-The language detector is a tool that can be used to detect the language of a given text. It uses a set of rules to detect the language of the text out of the box. Uses the best practices of prompt engineering and engineering to make the language detection as accurate as possible.
-
-```ruby
-require 'active_genie'
-
-text = "Example text to be detected"
-language = ActiveGenie::LanguageDetector.call(text)
-puts language # => "en"
-```
-
-### Translator (WIP)
-The translator is a tool that can be used to translate a given text. It uses a set of rules to translate the text out of the box. Uses the best practices of prompt engineering and engineering to make the translation as accurate as possible.
-
-```ruby
-require 'active_genie'
-
-text = "Example text to be translated"
-translated_text = ActiveGenie::Translator.call(text, from: 'en', to: 'pt')
-puts translated_text # => "Exemplo de texto a ser traduzido"
-```
-
-### Sentiment analyzer (WIP)
-The sentiment analyzer is a tool that can be used to analyze the sentiment of a given text. It uses a set of rules to analyze the sentiment of the text out of the box. Uses the best practices of prompt engineering and engineering to make the sentiment analysis as accurate as possible.
-
-```ruby
-require 'active_genie'
-
-text = "Example text to be analyzed"
-sentiment = ActiveGenie::SentimentAnalyzer.call(text)
-puts sentiment # => "positive"
-```
+### Text Summarizer (Future)
+### Language detector (Future)
+### Translator (Future)
+### Sentiment analyzer (Future)
 
 ## Configuration
 
@@ -218,6 +180,7 @@ puts sentiment # => "positive"
 3. Commit your changes (`git commit -m 'Add amazing feature'`)
 4. Push to the branch (`git push origin feature/amazing-feature`)
 5. Open a Pull Request
+
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the Apache License 2.0 License - see the [LICENSE](LICENSE) file for details.

data/VERSION

@@ -1 +1 @@
-0.0.10
+0.0.12

data/lib/active_genie/battle/basic.rb

@@ -14,8 +14,8 @@ module ActiveGenie::Battle
   #   Basic.call("Player A content", "Player B content", "Evaluate keyword usage and pattern matching")
   #
   class Basic
-    def self.call(player_a, player_b, criteria, config: {})
-      new(player_a, player_b, criteria, config:).call
+    def self.call(...)
+      new(...).call
     end
 
     # @param player_a [String] The content or submission from the first player
@@ -30,65 +30,55 @@ module ActiveGenie::Battle
       @player_a = player_a
       @player_b = player_b
       @criteria = criteria
-      @config = config
-      @response = nil
+      @config = ActiveGenie::Configuration.to_h(config)
     end
 
     def call
       messages = [
         {  role: 'system', content: PROMPT },
         {  role: 'user', content: "criteria: #{@criteria}" },
-        {  role: 'user', content: "player_a: #{player_content(@player_a)}" },
-        {  role: 'user', content: "player_b: #{player_content(@player_b)}" },
+        {  role: 'user', content: "player_a: #{@player_a}" },
+        {  role: 'user', content: "player_b: #{@player_b}" },
       ]
 
-      @response = ::ActiveGenie::Clients::UnifiedClient.function_calling(messages, FUNCTION, config:)
+      response = ::ActiveGenie::Clients::UnifiedClient.function_calling(
+        messages,
+        FUNCTION,
+        model_tier: 'lower_tier',
+        config: @config
+      )
 
-      response_formatted
+      response_formatted(response)
     end
 
     private
 
-    def player_content(player)
-      return player.dig('content') if player.is_a?(Hash)
+    def response_formatted(response)
+      winner = response['impartial_judge_winner']
+      loser = case response['impartial_judge_winner']
+              when 'player_a' then 'player_b'
+              when 'player_b' then 'player_a'
+              else 'draw'
+              end
 
-      player
-    end
-
-    def response_formatted
-      winner = case @response['winner']
-               when 'player_a' then @player_a
-               when 'player_b' then @player_b
-               end
-
-      @response.merge!('winner' => winner, 'loser' => winner ? (winner == @player_a ? @player_b : @player_a) : nil)
+      { winner:, loser:, reasoning: response['impartial_judge_winner_reasoning'] }
     end
 
     PROMPT = <<~PROMPT
-    Evaluate a battle between player_a and player_b using predefined criteria and identify the winner.
-
-    Consider rules, keywords, and patterns as the criteria for evaluation. Analyze the content from both players objectively, focusing on who meets the criteria most effectively. Explain your decision clearly, with specific reasoning on how the chosen player fulfilled the criteria better than the other. Avoid selecting a draw unless absolutely necessary.
+    Based on two players, player_a and player_b, they will battle against each other based on criteria. Criteria are vital as they provide a clear metric to compare the players. Follow these criteria strictly.
 
     # Steps
-    1. **Review Predefined Criteria**: Understand the specific rules, keywords, and patterns that serve as the basis for evaluation.
-    2. **Analyze Content**: Examine the contributions of both player_a and player_b. Look for how each player meets or fails to meet the criteria.
-    3. **Comparison**: Compare both players against each criterion to determine who aligns better with the standards set.
-    4. **Decision-Making**: Based on the analysis, determine the player who meets the most or all criteria effectively.
-    5. **Provide Justification**: Offer a clear and concise reason for your choice detailing how the winner outperformed the other.
-
-    # Examples
-    - **Example 1**:
-      - Input: Player A uses keyword X, follows rule Y, Player B uses keyword Z, breaks rule Y.
-      - Output: winner: player_a
-        - Justification: Player A successfully used keyword X and followed rule Y, whereas Player B broke rule Y.
+    1. Player_a sells himself, highlighting his strengths and how he meets the criteria. Max of 100 words.
+    2. Player_b sells himself, highlighting his strengths and how he meets the criteria. Max of 100 words.
+    3. Player_a argues why he is the winner compared to player_b. Max of 100 words.
+    4. Player_b counter-argues why he is the winner compared to player_a. Max of 100 words.
+    5. The impartial judge chooses which player as the winner.
 
-    - **Example 2**:
-      - Input: Player A matches pattern P, Player B matches pattern P, uses keyword Q.
-      - Output: winner: player_b
-        - Justification: Both matched pattern P, but Player B also used keyword Q, meeting more criteria.
+    # Output Format
+    - The impartial judge chooses this player as the winner.
 
     # Notes
-    - Avoid drawing if a clear winner can be discerned.
+    - Avoid resulting in a draw. Use reasoning or make fair assumptions if needed.
     - Critically assess each player's adherence to the criteria.
     - Clearly communicate the reasoning behind your decision.
     PROMPT
@@ -99,32 +89,33 @@ module ActiveGenie::Battle
       schema: {
         type: "object",
         properties: {
-          winner: {
+          player_a_sell_himself: {
             type: 'string',
-            description: 'The player who won the battle based on the criteria.',
-            enum: ['player_a', 'player_b', 'draw']
+            description: 'player_a sell himself, highlighting his strengths and how he meets the criteria. Max of 100 words.',
+          },
+          player_b_sell_himself: {
+            type: 'string',
+            description: 'player_b sell himself, highlighting his strengths and how he meets the criteria. Max of 100 words.',
           },
-          reasoning_of_winner: {
+          player_a_arguments: {
             type: 'string',
-            description: 'The detailed reasoning about why the winner won based on the criteria.',
+            description: 'player_a arguments why he is the winner compared to player_b. Max of 100 words.',
           },
-          what_could_be_changed_to_avoid_draw: {
+          player_b_counter: {
             type: 'string',
-            description: 'Suggestions on how to avoid a draw based on the criteria. Be as objective and short as possible. Can be empty.',
-          }
+            description: 'player_b counter arguments why he is the winner compared to player_a. Max of 100 words.',
+          },
+          impartial_judge_winner_reasoning: {
+            type: 'string',
+            description: 'The detailed reasoning about why the impartial judge chose the winner. Max of 100 words.',
+          },
+          impartial_judge_winner: {
+            type: 'string',
+            description: 'The impartial judge chose this player as the winner.',
+            enum: ['player_a', 'player_b', 'draw']
+          },
         }
       }
     }
-
-    def config
-      {
-        all_providers: { model_tier: 'lower_tier' },
-        log: {
-          **(@config.dig(:log) || {}),
-          trace: self.class.name,
-        },
-        **@config
-      }
-    end
   end
 end

data/lib/active_genie/clients/openai_client.rb

@@ -3,14 +3,17 @@ require 'net/http'
 
 module ActiveGenie::Clients
   class OpenaiClient
+    MAX_RETRIES = 3
+    
+    class OpenaiError < StandardError; end
+    class RateLimitError < OpenaiError; end
+
     def initialize(config)
       @app_config = config
     end
 
-    def function_calling(messages, function, config: {})
-      model = config[:model]
-      model = @app_config.tier_to_model(config.dig(:all_providers, :model_tier)) if model.nil? && config.dig(:all_providers, :model_tier)
-      model = @app_config.lower_tier_model if model.nil?
+    def function_calling(messages, function, model_tier: nil, config: {})
+      model = config[:model] || @app_config.tier_to_model(model_tier)
 
       payload = {
         messages:,
@@ -37,27 +40,69 @@ module ActiveGenie::Clients
     private
 
     def request(payload, headers, config:)
+      retries = config[:max_retries] || MAX_RETRIES
       start_time = Time.now
-      response = Net::HTTP.post(
-        URI("#{@app_config.api_url}/chat/completions"),
-        payload.to_json,
-        headers
-      )
+      
+      begin
+        response = Net::HTTP.post(
+          URI("#{@app_config.api_url}/chat/completions"),
+          payload.to_json,
+          headers
+        )
+
+        if response.is_a?(Net::HTTPTooManyRequests)
+          raise RateLimitError, "OpenAI API rate limit exceeded: #{response.body}"
+        end
+
+        raise OpenaiError, response.body unless response.is_a?(Net::HTTPSuccess)
 
-      raise OpenaiError, response.body unless response.is_a?(Net::HTTPSuccess)
-      return nil if response.body.empty?
+        return nil if response.body.empty?
 
-      parsed_body = JSON.parse(response.body)
-      log_response(start_time, parsed_body, config:)
+        parsed_body = JSON.parse(response.body)
+        # log_response(start_time, parsed_body, config:)
 
-      parsed_body
+        parsed_body
+      rescue OpenaiError, Net::HTTPError, JSON::ParserError, Errno::ECONNRESET, Errno::ETIMEDOUT, Net::OpenTimeout, Net::ReadTimeout => e
+        if retries > 0
+          retries -= 1
+          backoff_time = calculate_backoff(MAX_RETRIES - retries)
+          ActiveGenie::Logger.trace(
+            {
+              category: :llm,
+              trace: "#{config.dig(:log, :trace)}/#{self.class.name}",
+              message: "Retrying request after error: #{e.message}. Attempts remaining: #{retries}",
+              backoff_time: backoff_time
+            }
+          )
+          sleep(backoff_time)
+          retry
+        else
+          ActiveGenie::Logger.trace(
+            {
+              category: :llm,
+              trace: "#{config.dig(:log, :trace)}/#{self.class.name}",
+              message: "Max retries reached. Failing with error: #{e.message}"
+            }
+          )
+          raise
+        end
+      end
+    end
+
+    BASE_DELAY = 0.5
+    def calculate_backoff(retry_count)
+      # Exponential backoff with jitter: 2^retry_count + random jitter
+      # Base delay is 0.5 seconds, doubles each retry, plus up to 0.5 seconds of random jitter
+      # Simplified example: 0.5, 1, 2, 4, 8, 12, 16, 20, 24, 28, 30 seconds
+      jitter = rand * BASE_DELAY
+      [BASE_DELAY * (2 ** retry_count) + jitter, 30].min # Cap at 30 seconds
     end
 
     DEFAULT_HEADERS = {
       'Content-Type': 'application/json',
     }
 
-    def log_response(start_time, response, config:)
+    def log_response(start_time, response, config: {})
       ActiveGenie::Logger.trace(
         {
           **config.dig(:log),
@@ -70,8 +115,5 @@ module ActiveGenie::Clients
         }
       )
     end
-
-    # TODO: add some more rich error handling
-    class OpenaiError < StandardError; end
   end
 end

data/lib/active_genie/clients/unified_client.rb

@@ -1,13 +1,13 @@
 module ActiveGenie::Clients
   class UnifiedClient
     class << self
-      def function_calling(messages, function, config: {})
+      def function_calling(messages, function, model_tier: nil, config: {})
         provider_name = config[:provider]&.downcase&.strip&.to_sym
         provider = ActiveGenie.configuration.providers.all[provider_name] || ActiveGenie.configuration.providers.default
 
         raise InvalidProviderError if provider.nil? || provider.client.nil?
 
-        provider.client.function_calling(messages, function, config:)
+        provider.client.function_calling(messages, function, model_tier:, config:)
       end
 
       private

data/lib/active_genie/configuration/openai_config.rb

@@ -13,6 +13,14 @@ module ActiveGenie::Configuration
       @organization || ENV['OPENAI_ORGANIZATION']
     end
 
+    def api_url
+      @api_url || 'https://api.openai.com/v1'
+    end
+
+    def client
+      @client ||= ::ActiveGenie::Clients::OpenaiClient.new(self)
+    end
+
     def lower_tier_model
       @lower_tier_model || 'gpt-4o-mini'
     end
@@ -30,15 +38,7 @@ module ActiveGenie::Configuration
         lower_tier: lower_tier_model,
         middle_tier: middle_tier_model,
         upper_tier: upper_tier_model
-      }[tier&.to_sym]
-    end
-
-    def api_url
-      @api_url || 'https://api.openai.com/v1'
-    end
-
-    def client
-      @client ||= ::ActiveGenie::Clients::OpenaiClient.new(self)
+      }[tier&.to_sym] || lower_tier_model
     end
 
     def to_h(config = {})

data/lib/active_genie/data_extractor/README.md

@@ -65,7 +65,6 @@ The `from_informal` method extends the basic extraction by analyzing rhetorical
 - Litotes ("not bad", "isn't terrible")
 - Affirmative expressions ("sure", "no problem")
 - Negative expressions ("nah", "not really")
-- Hedging ("maybe", "I guess")
 
 ### Example
 

data/lib/active_genie/data_extractor/basic.rb

@@ -3,8 +3,8 @@ require_relative '../clients/unified_client'
 
 module ActiveGenie::DataExtractor
   class Basic
-    def self.call(text, data_to_extract, config: {})
-      new(text, data_to_extract, config:).call
+    def self.call(...)
+      new(...).call
     end
 
     # Extracts structured data from text based on a predefined schema.
@@ -46,7 +46,12 @@ module ActiveGenie::DataExtractor
         }
       }
 
-      ::ActiveGenie::Clients::UnifiedClient.function_calling(messages, function, config:)
+      ::ActiveGenie::Clients::UnifiedClient.function_calling(
+        messages,
+        function,
+        model_tier: 'lower_tier',
+        config: @config
+      )
     end
 
     private
@@ -59,10 +64,6 @@ module ActiveGenie::DataExtractor
     1. **Identify Data Types**: Determine the types of data to collect, such as names, dates, email addresses, phone numbers, etc.
     2. **Extract Information**: Use pattern recognition and language understanding to identify and extract the relevant pieces of data from the user message.
     3. **Categorize Data**: Assign the extracted data to the appropriate predefined fields.
-    4. **Structure Data**: Format the extracted and categorized data in a structured format, such as JSON.
-
-    # Output Format
-    The output should be a JSON object containing fields with their corresponding extracted values. If a value is not found, the field should still be included with a null value.
 
     # Notes
     - Handle missing or partial information gracefully.
@@ -83,16 +84,5 @@ module ActiveGenie::DataExtractor
       
       with_explaination
     end
-
-    def config
-      {
-        all_providers: { model_tier: 'lower_tier' },
-        log: {
-          **(@config.dig(:log) || {}),
-          trace: self.class.name,
-        },
-        **@config
-      }
-    end
   end
 end

data/lib/active_genie/data_extractor/from_informal.rb

@@ -1,7 +1,7 @@
 module ActiveGenie::DataExtractor
   class FromInformal
-    def self.call(text, data_to_extract, config: {})
-      new(text, data_to_extract, config:).call()
+    def self.call(...)
+      new(...).call()
     end
 
     # Extracts data from informal text while also detecting litotes and their meanings.
@@ -30,10 +30,10 @@ module ActiveGenie::DataExtractor
     end
 
     def call
-      response = Basic.call(@text, data_to_extract_with_litote, config:)
+      response = Basic.call(@text, data_to_extract_with_litote, config: @config)
 
       if response['message_litote']
-        response = Basic.call(response['litote_rephrased'], @data_to_extract, config:)
+        response = Basic.call(response['litote_rephrased'], @data_to_extract, config: @config)
       end
 
       response
@@ -54,16 +54,5 @@ module ActiveGenie::DataExtractor
         }
       }
     end
-
-    def config
-      {
-        all_providers: { model_tier: 'lower_tier' },
-        **@config,
-        log: {
-          **@config.dig(:log),
-          trace: self.class.name,
-        },
-      }
-    end
   end
 end

data/lib/active_genie/logger.rb

@@ -5,6 +5,16 @@ module ActiveGenie
   module Logger
     module_function
 
+    def with_context(context)
+      @context ||= {}
+      begin
+        @context = @context.merge(context)
+        yield if block_given?
+      ensure
+        @context.delete_if { |key, _| context.key?(key) }
+      end
+    end
+
     def info(log)
       save(log, level: :info)
     end
@@ -25,21 +35,38 @@ module ActiveGenie
       save(log, level: :trace)
     end
 
-    LOG_LEVELS = { info: 0, error: 1, warn: 2, debug: 3, trace: 4 }.freeze
-
-    def save(log, level: :info)
-      return if LOG_LEVELS[log.dig(:log, :log_level)] || -1 < LOG_LEVELS[level]
-
-      log[:trace] = log.dig(:trace)&.to_s&.gsub('ActiveGenie::', '')
+    def save(data, level: :info)
+      log = @context.merge(data || {})
       log[:timestamp] = Time.now
       log[:level] = level.to_s.upcase
       log[:process_id] = Process.pid
+      config_log_level = LOG_LEVELS[log.dig(:config, :log_level)] || LOG_LEVELS[:info]
 
       FileUtils.mkdir_p('logs')
       File.write('logs/active_genie.log', "#{JSON.generate(log)}\n", mode: 'a')
-      puts log
+      if config_log_level >= LOG_LEVELS[level]
+        $stdout.puts log
+      else
+        $stdout.print '.'
+      end
 
       log
     end
+
+    private
+
+    # Log Levels
+    # 
+    # LOG_LEVELS defines different levels of logging within the application. 
+    # Each level serves a specific purpose, balancing verbosity and relevance.
+    # 
+    # - :info  -> General log messages providing an overview of application behavior, ensuring readability without excessive detail.
+    # - :warn  -> Indicates unexpected behaviors that do not halt execution but require attention, such as retries, timeouts, or necessary conversions.
+    # - :error -> Represents critical errors that prevent the application from functioning correctly.
+    # - :debug -> Provides detailed logs for debugging, offering the necessary context for audits but with slightly less detail than trace logs.
+    # - :trace -> Logs every external call with the highest level of detail, primarily for auditing or state-saving purposes. These logs do not provide context regarding triggers or reasons.
+    LOG_LEVELS = { info: 0, error: 0, warn: 1, debug: 2, trace: 3 }.freeze
+
+    attr_accessor :context
   end
 end