dvla-herodotus 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e438adf38dbfed19a683688cbd116e9df9cd2381c64142ce1334eeea84ae681c
-  data.tar.gz: 6c4fc10b6f03e57261971d56fb86570283020c48217bdb4cdbb7ed6920a2a894
+  metadata.gz: 6e3ef91707cd06f7a091f1648f34606d50e88feac527ba1addf96dfe9b9fd0cd
+  data.tar.gz: 96f8a2e8b39f34c3552e7ad7f5824c8facbd1af79b29a76fc9254f465d9c8d6a
 SHA512:
-  metadata.gz: c4942f36ded7e851ba5e9a43254dd02ec02a3e2bf1df3580103502873fe16d2f28787960c0277417c415103411f17d8396fe4947f5feeead0ac408cbf928756c
-  data.tar.gz: '095addb8fe673dcf789bec32357bad374aec2ffc6fc58e7331fbf20070dc22680630ca386ea5dc6b5a4fa2114e6ed701787747cd988d171788cf1a444bddf8c8'
+  metadata.gz: 357756d95d6774075440eba3f1cc7f7c38d1980586a0e0d82cefae36e959b6a3ba18406b77a87617ccc34cb320e0d3e9e3ded369b5f8db1bae62f97b30f2e809
+  data.tar.gz: e32fe8df4155456455e275601a7f885c8596b9c6700aa73e00169b67b63658fc49f3c8799e6d09a18048c0f4eff61ce17d4a55b37f09e15a102c08d9badccc89

data/.github/workflows/gem-build.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [ '3.0', '3.1', '3.2' ]
+        ruby-version: [ '3.0', '3.1', '3.2', head ]
 
     steps:
       - uses: actions/checkout@v2

data/.github/workflows/gem-push.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [ '3.0', '3.1', '3.2' ]
+        ruby-version: [ '3.0', '3.1', '3.2', head ]
 
     steps:
       - uses: actions/checkout@v2
@@ -30,10 +30,10 @@ jobs:
 
     steps:
       - uses: actions/checkout@v2
-      - name: Set up Ruby 3.0.1
+      - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.1.2
+          ruby-version: 3.3.0
           bundler-cache: true
 
       - name: Publish to RubyGems

data/.github/workflows/gem-test.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [ '3.0', '3.1', '3.2' ]
+        ruby-version: [ '3.0', '3.1', '3.2', head ]
 
     steps:
       - uses: actions/checkout@v2

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/README.md

@@ -18,6 +18,7 @@ Or install it yourself as:
 
     $ gem install dvla-herodotus
 
+---
 ## Usage
 
 ### Logger
@@ -25,60 +26,60 @@ Or install it yourself as:
 You can get a logger by calling the following once Herodotus is installed:
 
 ```ruby
-logger = DVLA::Herodotus.logger
+logger = DVLA::Herodotus.logger('<system-name>')
 ```
 
 You can also log out to a file. If you want all the logs in a single file, provide a string of the path to that output file and it will be logged to simultaneously with standard console logger
 
 ```ruby
-logger = DVLA::Herodotus.logger(output_path: 'logs.txt')
+logger = DVLA::Herodotus.logger('<system-name>', output_path: 'logs.txt')
 ```
 
 Alternatively, if you want each scenario to log out to a separate file based on the scenario name, pass in a lambda that returns a string that attempts to interpolate `@scenario`.
 
 ```ruby
-logger = DVLA::Herodotus.logger(output_path: -> { "#{@scenario}_log.txt" })
+logger = DVLA::Herodotus.logger('<system-name>', output_path: -> { "#{@scenario}_log.txt" })
 ```
 
 This is a standard Ruby logger, so anything that would work on a logger acquired the traditional way will also work here, however it is formatted such that all logs will be output in the following format:
 
-`[CurrentDate CurrentTime CorrelationId] Level : -- Message`
 
-Additionally, you can configure Herodotus in the following way to add a System Name and the Process Id to the output:
+`[SystemName CurrentDate CurrentTime CorrelationId] Level : -- Message`
+
+### Configuration
+You can configure Herodotus in the following way to add a Process Id to the output:
 
 ```ruby
-DVLA::Herodotus.configure do |config|
-  config.system_name = 'SystemName'
-  config.pid = true
+config = DVLA::Herodotus.config do |config|
+  config.display_pid = true
 end
+logger = DVLA::Herodotus.logger('<system-name>', config: config)
 ```
 
 This would result in logs in the following format:
 
 `[SystemName CurrentDate CurrentTime CorrelationId PID] Level : -- Message`
 
-Additionally, if you wish to have different correlation ids based on the scenario that is being currently being run, you can pass a unique identifier for your scenario as part of the logging call, with each scenario having a unique correlation id.
+### Syncing logs
 
-```ruby
-logger.info('String to log out', 'Scenario Id')
-```
+Herodotus allows you to Sync correlation_ids between instantiated HerodotusLogger objects. 
 
-Alternatively, you can call `new_scenario` with the identifier just before each scenario to achieve the same result without having to pass the identifier around.
+The HerodotusLogger flagged as `main` will be used as the source.
 
 ```ruby
-logger.new_scenario('Scenario Id')
+config = DVLA::Herodotus.config do |config|
+  config.main = true
+end
+main_logger = DVLA::Herodotus.logger('<system-name>', config: config)
 ```
 
-Finally, you can set Herodotus up to integrate with any other instances of Herodotus that are loaded indirectly into your application, for example within a gem you use. To take advantage of this, when configuring Herodotus within your project, ensure that you set its `merge` value to true, as below:
+### new_scenario method
+You can call `new_scenario` with the identifier just before each scenario to create a unique correlation_id per scenario.
 
 ```ruby
-DVLA::Herodotus.configure do |config|
-  config.merge = true
-end
+logger.new_scenario('Scenario Id')
 ```
 
-This will cause your correlation ids to be shared out with all the loggers that exist outside of our direct control. The instance of the Herodotus that will take precedence will be the last one to be loaded, which should be the one you are creating with `DVLA::Herodotus.logger`. 
-
 ### Strings
 
 Also included is a series of additional methods on `String` that allow you to modify the colour and style of logs. As these exist on `String`, you can call them on any string such as:

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'dvla/herodotus'
+require 'irb'
+
+IRB.start(__FILE__)

data/lib/dvla/herodotus/herodotus_logger.rb

@@ -3,73 +3,86 @@ require 'securerandom'
 module DVLA
   module Herodotus
     class HerodotusLogger < Logger
-      attr_accessor :system_name, :requires_pid, :merge, :correlation_ids
+      attr_accessor :system_name, :correlation_id, :main, :display_pid, :scenario_id
 
-      def register_default_correlation_id
-        @correlation_ids = { default: SecureRandom.uuid[0, 8] }
-        @current_scenario = :default
-        reset_format
+      # Initializes the logger
+      # Sets a default correlation_id and creates the formatter
+      # Syncs all instances of the HerodotusLogger when the main flag is present
+      # Any subsequent loggers will also be synced
+      def initialize(system_name, *args, config: DVLA::Herodotus.config, **kwargs)
+        super(*args, **kwargs)
+
+        @system_name = system_name
+        @main = config[:main]
+        @display_pid = config[:display_pid]
+
+        @correlation_id = SecureRandom.uuid[0, 8]
+        set_formatter
+
+        if DVLA::Herodotus.main_logger && @main
+          warn("Main logger already set: '#{DVLA::Herodotus.main_logger.system_name}'. This will be overwritten by '#{system_name}'")
+        end
+
+        DVLA::Herodotus.main_logger = self if @main
+        sync_correlation_ids if DVLA::Herodotus.main_logger
       end
 
+      # Creates a new correlation_id and re-creates the formatter per scenario.
+      # If this method is called on an instance of HerodotusLogger not flagged as main
+      # the correlation_id of the main logger will be updated and all logger's correlation_ids re-synced.
       def new_scenario(scenario_id)
-        update_format(scenario_id)
-        merge_correlation_ids(new_scenario: scenario_id) if @merge
+        @scenario_id = scenario_id
+        @correlation_id = SecureRandom.uuid[0, 8]
+
+        if DVLA::Herodotus.main_logger && self != DVLA::Herodotus.main_logger
+          warn('You are calling new_scenario on a non-main logger.')
+
+          DVLA::Herodotus.main_logger.correlation_id = @correlation_id
+          DVLA::Herodotus.main_logger.scenario_id = @scenario_id
+        end
+
+        set_formatter
+        sync_correlation_ids if DVLA::Herodotus.main_logger
       end
 
-      def merge_correlation_ids(new_scenario: nil)
+      # Finds all instances of HerodotusLogger and updates their correlation_id and scenario_id
+      # to match that of the main HerodotusLogger.
+      def sync_correlation_ids
         ObjectSpace.each_object(DVLA::Herodotus::HerodotusLogger) do |logger|
-          unless logger == self # This copies the correlation ids this logger has over to all other loggers and (assuming a new scenario has just been switched to) updates the those loggers to the current scenario
-            logger.merge = false if logger.merge #Stops the other logger from trying to propagate its correlation ids to all other loggers, otherwise this code ends up in an infinite loop
-            logger.correlation_ids = self.correlation_ids
-            logger.new_scenario(new_scenario) unless new_scenario.nil?
+          unless logger == DVLA::Herodotus.main_logger
+            logger.correlation_id = DVLA::Herodotus.main_logger.correlation_id
+            logger.scenario_id = DVLA::Herodotus.main_logger.scenario_id
+            logger.set_formatter
           end
         end
       end
 
       %i[debug info warn error fatal].each do |log_level|
-        define_method log_level do |progname = nil, scenario_id = nil, &block|
-          if scenario_id == nil
-            set_proc_writer_scenario
-            super(progname, &block)
-          else
-            update_format(scenario_id)
-            set_proc_writer_scenario
-            super(progname, &block)
-            reset_format
-          end
+        define_method log_level do |progname = nil, &block|
+          set_proc_writer_scenario
+          super(progname, &block)
         end
       end
 
-    private
-
-      def update_format(scenario_id)
-        @current_scenario = scenario_id
-        @correlation_ids[scenario_id] = SecureRandom.uuid[0, 8] unless @correlation_ids.key?(scenario_id)
-
+      # Sets the format of the log.
+      # Needs to be called each time correlation_id is changed after initialization in-order for the changes to take affect.
+      def set_formatter
         self.formatter = proc do |severity, _datetime, _progname, msg|
-          "[#{@system_name}" \
+          "[#{@system_name} " \
             "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} " \
-            "#{@correlation_ids[scenario_id]}" \
-            "#{' '.concat(Process.pid.to_s) if requires_pid}] " \
+            "#{@correlation_id}" \
+            "#{' '.concat(Process.pid.to_s) if @display_pid}] " \
             "#{severity} -- : #{msg}\n"
         end
       end
 
-      def reset_format
-        self.formatter = proc do |severity, _datetime, _progname, msg|
-          "[#{@system_name}" \
-            "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} " \
-            "#{@correlation_ids[:default]}" \
-            "#{' '.concat(Process.pid.to_s) if requires_pid}] " \
-            "#{severity} -- : #{msg}\n"
-        end
-      end
+    private
 
       def set_proc_writer_scenario
         if @logdev.dev.is_a?(DVLA::Herodotus::MultiWriter) && @logdev.dev.targets.any?(DVLA::Herodotus::ProcWriter)
           proc_writers = @logdev.dev.targets.select { |t| t.is_a? DVLA::Herodotus::ProcWriter }
           proc_writers.each do |pr|
-            pr.scenario = @current_scenario
+            pr.scenario = @scenario_id
           end
         end
       end

data/lib/dvla/herodotus/version.rb

@@ -1,5 +1,5 @@
 module DVLA
   module Herodotus
-    VERSION = '1.2.1'.freeze
+    VERSION = '2.0.0'.freeze
   end
 end

data/lib/dvla/herodotus.rb

@@ -6,41 +6,35 @@ require_relative 'herodotus/string'
 
 module DVLA
   module Herodotus
-    CONFIG_ATTRIBUTES = %i(system_name pid merge).freeze
-
-    def self.configure
-      @config ||= Struct.new(*CONFIG_ATTRIBUTES).new
-      yield(@config) if block_given?
-      @config
+    class << self
+      attr_accessor :main_logger
     end
 
+    CONFIG_ATTRIBUTES = %i[display_pid main].freeze
+
     def self.config
-      @config || configure
+      config ||= Struct.new(*CONFIG_ATTRIBUTES, keyword_init: true).new
+      yield(config) if block_given?
+      config
     end
 
-    def self.logger(output_path: nil)
-      logger = create_logger(output_path)
-      logger.system_name = "#{config.system_name} " unless config.system_name.nil?
-      logger.requires_pid = config.pid
-      logger.merge = config.merge
-      logger.register_default_correlation_id
-      logger.merge_correlation_ids if config.merge
-      logger
+    def self.logger(system_name, config: self.config, output_path: nil)
+      create_logger(system_name, config, output_path)
     end
 
-    private_class_method def self.create_logger(output_path)
+    private_class_method def self.create_logger(system_name, config, output_path)
       if output_path
         if output_path.is_a? String
           output_file = File.open(output_path, 'a')
-          return HerodotusLogger.new(MultiWriter.new(output_file, $stdout))
+          return HerodotusLogger.new(system_name, MultiWriter.new(output_file, $stdout), config: config)
         elsif output_path.is_a? Proc
           proc_writer = ProcWriter.new(output_path)
-          return HerodotusLogger.new(MultiWriter.new(proc_writer, $stdout))
+          return HerodotusLogger.new(system_name, MultiWriter.new(proc_writer, $stdout), config: config)
         else
           raise ArgumentError.new 'Unexpected output_path provided. Expecting either a string or a proc'
         end
       end
-      HerodotusLogger.new($stdout)
+      HerodotusLogger.new(system_name, $stdout, config: config)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dvla-herodotus
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Driver and Vehicle Licensing Agency (DVLA)
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
+date: 2024-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dvla-lint
@@ -51,9 +51,11 @@ files:
 - ".github/workflows/gem-test.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".ruby-version"
 - Gemfile
 - LICENSE
 - README.md
+- bin/console
 - dvla-herodotus.gemspec
 - lib/dvla/herodotus.rb
 - lib/dvla/herodotus/herodotus_logger.rb
@@ -80,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
 summary: Provides a lightweight logger with a common format