hubbado-log 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c548a1c52601a45c8ffb53337dcfe28805e63cbe868d90692f5bff54b8fc4f82
-  data.tar.gz: da676bfa5ff5ee43efa7660412ea53da1c307e4fdadf8570cc6bd1251178c60b
+  metadata.gz: 99367c1895c07697aa0e83dc1e068f35cf2052d75dc6c471610b47099f27fd7f
+  data.tar.gz: 58a148cfa36ea3709a2c36fbb228f089d3b176476d27ede4a74ec26a651bdf12
 SHA512:
-  metadata.gz: d7a795d9bc507c468e12232058d413c916f8f6e155f68793e6305314c50c7bf8e5528a690280c9b9b265824cf6e8cb6e428741aaa4df0abe6550dcf9cc0fb636
-  data.tar.gz: 308912bee3a3af9ca487628ba15cadbe74f33fdce80ee329585229a34b7bae25f832167c2d7250189fa50b6d30c0ad4d7a3e07fdb78e8e207f0032f8f31d44b0
+  metadata.gz: 5a53b16af1babaa5c90125bfddec34a02c5256661004833a63b5b54066a914bf764d2c3c738d0a0d2e556d4bd9ef86d96d7e40419e7acd810f2fb7ca4fe58788
+  data.tar.gz: 6f77c77d30c8a1ef7f89b2b73c8e09585aa3f39d6dd5d9046796220f699f2926c31debd5fb5b8f514e06c7a2fb66e2b5e20be6cf7f86b95e56bba6218a2ef5e5

data/ChangeLog.md

@@ -4,6 +4,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+# [1.4.1 - 2026-08-16]
+## Fixed
+- A subclass of `Hubbado::Log` can be used as a dependency. It answered `nil`
+  from `config` and raised `undefined method 'loggers' for nil` on its first
+  line, because the configuration was held in a class-level instance variable
+  and those are not inherited.
+
+  ```ruby
+  module Messaging
+    class Log < Hubbado::Log; end
+  end
+
+  class Handler
+    include Messaging::Log::Dependency
+  end
+  ```
+
+  The configuration is the process's now, and holds the handlers built from it,
+  so every class that writes reads the one a command configured and one
+  reconfiguration reaches all of them.
+
 # [1.4.0 - 2026-08-16]
 ## Added
 - A substitute for a logger. `Controls::Logger.example` returns one, and a spec

data/README.md

@@ -18,6 +18,36 @@ Or install it yourself as:
 
     $ gem install hubbado-log
 
+## A class's own logger
+
+A class that includes the dependency module gets a `logger` writing under its own name:
+
+```ruby
+class MyService
+  include Hubbado::Log::Dependency
+
+  def call
+    logger.info('Did the thing')
+  end
+end
+```
+
+A subclass carries a dependency module of its own, so a library or a component can name where
+its classes take their logger from:
+
+```ruby
+module Messaging
+  class Log < Hubbado::Log; end
+end
+
+class Handler
+  include Messaging::Log::Dependency
+end
+```
+
+Either way the logger writes through the handlers the process was configured with, at the level
+and tags it was configured for.
+
 ## Level
 
 A message below the level reaches no handler.

data/hubbado-log.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "hubbado-log"
-  s.version = "1.4.0"
+  s.version = "1.4.1"
   s.summary = "Lightweight pluggable logging system"
 
   s.authors = ["Hubbado Devs"]

data/lib/hubbado/log/configuration.rb

@@ -5,16 +5,45 @@ module Hubbado
       # for a human watching one run without it also reaching every unattended log.
       DEFAULT_LEVEL = :info
 
-      attr_accessor :loggers
+      attr_reader :loggers
       attr_reader :level
       attr_reader :tags
 
+      # The configuration is the process's rather than a class's, so a subclass of Log reads the
+      # one a command wrote and there is a single set of handlers to build from it.
+      #
+      # The one place the environment is read. A command names its level and tags here or not at
+      # all, and everything downstream is handed the value rather than the variable.
+      def self.instance
+        @instance ||= new(level: ENV[LEVEL_VARIABLE], tags: ENV[TAGS_VARIABLE])
+      end
+
       def initialize(level: nil, tags: nil)
-        @loggers = []
+        self.loggers = []
         self.level = level || DEFAULT_LEVEL
         self.tags = tags
       end
 
+      # Whatever the block leaves behind is what the process is configured for, and the handlers
+      # are built again from it. Named here rather than left to the caller, because a block is
+      # free to mutate the list of loggers in place and never reach the writer below.
+      def change
+        yield self
+
+        @log_handlers = nil
+      end
+
+      # The handlers themselves, one set for the process. A handler holds what it has been told,
+      # so a second set built somewhere else would be a second place to read it back from.
+      def log_handlers
+        @log_handlers ||= loggers.map(&:new)
+      end
+
+      def loggers=(value)
+        @log_handlers = nil
+        @loggers = value
+      end
+
       # Takes the LOG_TAGS string as readily as a list, so nothing upstream has to know the
       # syntax in order to hand a value in.
       def tags=(value)

data/lib/hubbado/log/log.rb

@@ -11,22 +11,16 @@ module Hubbado
     LEVEL_VARIABLE = "LOG_LEVEL".freeze
     TAGS_VARIABLE = "LOG_TAGS".freeze
 
-    # The one place the environment is read. A command names its level and tags here or not at
-    # all, and everything downstream is handed the value rather than the variable.
-    @config = Configuration.new(level: ENV[LEVEL_VARIABLE], tags: ENV[TAGS_VARIABLE])
-
     class << self
-      attr_reader :config
-
-      def configuration
-        yield @config
+      # Held by the configuration itself rather than here, because a class-level instance
+      # variable is not inherited: a subclass asking this class would answer nil.
+      def config = Configuration.instance
 
-        @loggers = nil
+      def configuration(&block)
+        config.change(&block)
       end
 
-      def loggers
-        @loggers ||= config.loggers.map(&:new)
-      end
+      def loggers = config.log_handlers
 
       def logger
         @logger = Logger.new('', loggers)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hubbado-log
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Hubbado Devs