hubbado-log 1.5.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84cb20198caa8a5346b0a4d50c702b57e77f53cedc2f90e221c05a90985260a0
-  data.tar.gz: 1134a1d43db622684732e5550d76716c8be4dcb5ee0e23382c8aaaedf0743851
+  metadata.gz: 583b7b7da5c4402a941dc3383961ac3af980078123d1ea2618ee89dced2d431b
+  data.tar.gz: 8268fb5b20c2ba01a9b402cf6a6ea950139bb34e5573bf666e38a6689187acec
 SHA512:
-  metadata.gz: ac99e3a37b28025006034cd5032a350db0c3e0bf63ee1c504c4af81a589879a5d1e3dd72180592b5d1632471b0f00efe9353cc5dfc6f1b040bf6855370a1f537
-  data.tar.gz: 97fe613dccb476915983d4836ae3736e3fae54168872b20106a71da9e1ec70c40994a7ba79d2931f8fdfc5dd4b36defdc55bf52823de6194b2e552c2ff84f49c
+  metadata.gz: a8893a6eb651bfbecef02fb88d0b0c51c468f77ae946ddf57522858e5a82fe4aea7d3468d80e1023fd15fc0b11973e0f8bc6104eb113d774a29d941b0b5010f4
+  data.tar.gz: d448240a1a0f37894a8e79d1558406cf16d327c8d99a7b5222ba29dd1285dc35680c2311b8d31ea33af4d07e32ac2c905225562953c978611d91f55ff8a7fb4e

data/ChangeLog.md

@@ -4,6 +4,115 @@ 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/).
 
+# [2.0.0 - 2026-08-29]
+## Fixed
+- `LOG_TAGS` and `LOG_LEVEL` no longer decide whether a failure is reported.
+  Both were applied in `Logger`, above the handler fan-out, so an operator
+  narrowing the log to the step they were debugging, or raising the level to cut
+  what an unattended log costs to keep, also stopped `NotifyRollbar` filing the
+  incident. A crash in any other step went unreported.
+
+  `StderrLogger` and `RailsLogger` now ask `Display` for themselves before
+  writing. `NotifyRollbar` does not ask, so it is reached whatever the settings
+  say, and declines anything below `warn` on its own as before.
+
+- A failure written with a String severity is given a stacktrace, as one written
+  with a symbol always was. `#log` validates the severity as a symbol but
+  compared it raw when deciding whether to synthesise a caller stack, so
+  `Hubbado::Log.log('error', msg)` was accepted, logged, and arrived with no
+  stack under it.
+
+  Latent until now — every call site across Hubbado names its severity as a
+  symbol — and worth fixing here because such a message could previously be
+  filtered away entirely. Now that every warning and error reaches Rollbar, it
+  would instead be filed as an item nobody can act on.
+
+## Added
+- `Hubbado::Log::Display`, which answers whether the operator asked to be shown
+  a message. A handler that writes where a person reads asks it; one that
+  reports an incident does not.
+
+  ```ruby
+  class MyHandler < Hubbado::Log::LogHandler
+    def log(subject, severity, message, data = nil, stacktrace = nil, tags = nil)
+      return unless Hubbado::Log::Display.shows?(severity, tags)
+
+      ...
+    end
+  end
+  ```
+
+  A printing handler that forgets to ask prints everything, whatever the
+  operator set.
+
+- `LogHandler#traces?(severity, tags)`, asked before a stacktrace is made.
+  `Kernel.caller` costs more than the rest of a log call put together — around
+  19µs at a Rails stack depth against 0.8µs — and it was being paid for messages
+  no handler would use.
+
+  It answers `true`, so a handler written before this existed is asked nothing
+  and keeps the stacktrace it always had. `StderrLogger` answers `false` below
+  `error`, which is where it stops printing one; `NotifyRollbar` answers `false`
+  below `warn`, which is where it stops reporting.
+
+  | | Was | Is now |
+  |---|---|---|
+  | an error the tag list left out | 29.2µs | 1.9µs |
+  | a warning on a terminal | 19µs | 1.6µs |
+
+  The second of those is older than this release: the gem synthesised a
+  stacktrace for every `warn`, and `StderrLogger` has always declined to print
+  one below `error`.
+
+- The logger substitute names a line by its message and its tags, not only by
+  its severity. `logged?`, `messages` and `logged` all take the same criteria.
+
+  ```ruby
+  assert logger.logged?(:info, message: /handed back/, tags: %i[rescoring sweep])
+  ```
+
+  Named together rather than one at a time, because a run writes several lines
+  and a message and a tag list asserted apart can each be true of a different
+  one. Before this, a spec asking about a line's tags reached past the
+  substitute into `invocations.first.arguments.fetch(:tag)` — which bound the
+  assertion to which keyword the call site happened to use, so rewriting
+  `tag: :claim` to `tags: [:claim]` broke a spec without changing any behaviour.
+
+  `message:` matches a String in full or a Regexp in part. `tags:` takes one
+  symbol or a list, reads both keywords as the logger does, and names every tag
+  the line carries and no others, in any order.
+
+  Entries answered by `logged` carry `tags` alongside `severity`, `message` and
+  `data`.
+
+## Breaking
+- **`LOG_LEVEL` and `LOG_TAGS` no longer hold Rollbar volume down.** That is the
+  point of the fix above, and it is a change to what an operator can do: a
+  process running `LOG_LEVEL=error`, or a narrowed list, to keep the incident
+  count low loses that lever on upgrade. Every `warn` and above now files,
+  whatever the settings say, and `NotifyRollbar`'s own `warn` floor is the only
+  one left. Rollbar's own rate limiting is where volume is held now.
+- **`LogHandler#log` takes a sixth argument**, the tags the message was written
+  with, as symbols. A handler defining five parameters raises when called — and
+  raises from inside the logging call, so it takes down the operation being
+  logged rather than only the log line. A keyword with a default would not have
+  softened this: Ruby folds a trailing hash into a sixth positional for a method
+  that declares no keywords, and it raises identically.
+- **The per-logger `level:` and `tags:` overrides are gone.** `Logger.new` takes
+  a subject and its handlers, and nothing else; a handler reads the process's
+  configuration. Nothing across Hubbado set either — only this gem's own
+  controls did. This is a deliberate divergence from Eventide's log gem, which
+  keeps that seam: restoring it would mean putting the effective level and list
+  back onto the handler contract that this release widened.
+- **`Controls::LogHandler.attach` and `.logger` no longer take `level:` or
+  `tags:`.** The control records rather than displays, so nothing filters what a
+  spec attaching one can read.
+
+## Changed
+- A message tagged `:*` now means only "display this whatever the list says",
+  which is what it means in Eventide's log gem. It is no longer what keeps an
+  incident alive, because nothing can silence one.
+
 # [1.5.0 - 2026-08-16]
 ## Added
 - Three handlers, replacing eight hand-rolled copies across four projects and

data/README.md

@@ -65,7 +65,9 @@ the application's — a Rails logger, a Rollbar token. Write one by subclassing
 
 ```ruby
 class MyHandler < Hubbado::Log::LogHandler
-  def log(subject, severity, message, data = nil, stacktrace = nil)
+  def log(subject, severity, message, data = nil, stacktrace = nil, tags = nil)
+    return unless Hubbado::Log::Display.shows?(severity, tags)
+
     ...
   end
 end
@@ -73,7 +75,21 @@ end
 
 `data` is whatever the call site passed as the second argument, and is an `Exception` when it
 logged one. `stacktrace` is the exception's `full_message` in that case, and otherwise the caller
-stack, synthesised for `warn`, `error`, `fatal` and `unknown` only.
+stack, synthesised for `warn`, `error`, `fatal` and `unknown` only. `tags` is what the message was
+tagged with, as symbols.
+
+**A handler that writes where a person reads asks `Display.shows?` first**, and one that reports
+an incident does not — see [Display and reporting](#display-and-reporting).
+
+A handler is also asked whether it would use a stacktrace, before one is made:
+
+```ruby
+def traces?(severity, tags = nil) = Hubbado::Log::Display.shows?(severity, tags)
+```
+
+It answers `true` unless you say otherwise, so a handler that ignores it keeps what it always had.
+Answering honestly is worth it — `Kernel.caller` costs more than the rest of a log call put
+together, and a message no handler traces should not pay for it.
 
 ### `Hubbado::Log::StderrLogger`
 
@@ -180,7 +196,8 @@ back.
 
 ## Level
 
-A message below the level reaches no handler.
+A message below the level is not displayed. It still reaches a handler that reports — see
+[Display and reporting](#display-and-reporting).
 
 ```ruby
 Hubbado::Log.configuration do |config|
@@ -206,9 +223,6 @@ Levels, lowest first:
 | `error` | Message logged just prior to raising an error |
 | `fatal` | Message recorded, when possible, as the process is terminating due to an error |
 
-A single logger can name its own with
-`Hubbado::Log::Logger.new(subject, handlers, level: :debug)`.
-
 `LOG_LEVEL` is shared with Eventide's log gem, which writes names this gem does not
 know. A name that is not one of `debug`, `info`, `warn`, `error`, `fatal` or
 `unknown` leaves the level at `info` rather than raising.
@@ -228,7 +242,7 @@ logger.trace('Row read', tag: :data)
 
 ### `LOG_TAGS`
 
-Which tagged messages are written is decided by `LOG_TAGS`, a comma-separated list:
+Which tagged messages are displayed is decided by `LOG_TAGS`, a comma-separated list:
 
     $ LOG_TAGS='_untagged,-data,billing,invoicing' ./my-command
 
@@ -247,20 +261,14 @@ Eventide's behaviour, kept deliberately so one `LOG_TAGS` means the same thing t
 
 Tags compose with the level rather than replacing it: both filters have to pass, so a tag
 cannot raise a message above the level and the level cannot rescue one the list leaves out.
-
-A single logger can name its own list, as it can name its own level, so one component can be
-read without turning up everything around it:
-
-```ruby
-Hubbado::Log::Logger.new(subject, handlers, level: :trace, tags: '_all')
-```
+Both decide what is displayed, and neither decides what is reported.
 
 The syntax and its behaviour are Eventide's log gem, copied deliberately so that a string an
 operator writes means the same thing in both codebases. Two consequences of that are worth
 knowing before adopting tags:
 
-- **`LOG_TAGS` is an allow-list.** A tagged message is written only if the list names it. Adding
-  a tag to a call site therefore *silences* that message everywhere `LOG_TAGS` has not been
+- **`LOG_TAGS` is an allow-list.** A tagged message is displayed only if the list names it. Adding
+  a tag to a call site therefore *hides* that message everywhere `LOG_TAGS` has not been
   updated — cron, CI and production included. Ship the variable with the tag.
 - **There is no way to mute one concern and keep the rest.** `-name` subtracts only from
   messages an include has already matched, and `_all` is answered before any exclusion, so
@@ -271,6 +279,27 @@ knowing before adopting tags:
 list decides for both, and an application whose messages are all untagged goes silent unless the
 list contains `_untagged`.
 
+## Display and reporting
+
+`LOG_LEVEL` and `LOG_TAGS` decide what is displayed, not what is reported: an operator narrowing
+to the step they are debugging is asking to be shown less, not for a crash elsewhere to go
+unreported.
+
+The logger fans every message out to every handler. One that writes where a person reads asks
+first; one that reports does not:
+
+```ruby
+Hubbado::Log::Display.shows?(severity, tags)   # => true if the level and the list both admit it
+```
+
+`StderrLogger` and `RailsLogger` ask. `NotifyRollbar` does not, and declines below `warn` itself.
+
+**A printing handler that forgets to ask prints everything.** That is the thing to remember when
+writing one.
+
+Tagging a `warn` no longer hides it from Rollbar, only from the terminal, and `:*` now means
+"always display" — what it means in Eventide's log gem.
+
 ## Reading back what a class logged
 
 A spec assigns a substitute where the class's logger goes, and then asks what the class said:
@@ -299,23 +328,40 @@ assert logger.logged?(:error)
 It records what it was told rather than writing, so no handler is involved and neither the
 configured level nor `LOG_TAGS` decides what can be read back.
 
-Three questions, each taking an optional severity:
+Three questions, each taking the same criteria:
 
 | Call | Answers |
 |---|---|
-| `logged?` / `logged?(:warn)` | whether anything was written, at all or at that severity |
-| `messages` / `messages(:warn)` | what it said — the message strings, in order |
-| `logged` / `logged(:warn)` | everything about what it said |
+| `logged?` | whether a line matching was written |
+| `messages` | what those lines said — the message strings, in order |
+| `logged` | everything about them |
+
+| Criterion | Names a line by |
+|---|---|
+| a severity, positionally | `logged?(:warn)` |
+| `message:` | a String matching in full, or a Regexp matching part |
+| `tags:` | the tags it carries, compared as a set — one symbol or a list |
+
+**Name them together rather than one at a time.** A run writes several lines, and a message and a
+tag list asserted apart can each be true of a different one:
+
+```ruby
+assert logger.logged?(:info, message: /handed back/, tags: %i[rescoring sweep])
+```
+
+`tags:` names every tag the line carries and no others, in any order. It reads both keywords as
+the logger does, so a call site rewritten from `tag: :claim` to `tags: [:claim]` — a change with
+no behaviour in it — does not break the spec.
 
-`logged` answers with entries carrying `severity`, `message` and `data`, for the assertion that
-needs more than the text:
+`logged` answers with entries carrying `severity`, `message`, `data` and `tags`, for the assertion
+that needs more than a yes:
 
 ```ruby
 assert logger.logged(:error).first.data.equal?(exception)
 ```
 
-`messages` and `logged?` are both derived from `logged`, so the three cannot disagree about what
-counts as written at a severity.
+`messages` and `logged?` are both derived from `logged`, so the three cannot disagree about which
+lines are being talked about.
 
 A severity reaches a logger two ways — `logger.warn('…')` names it as the method,
 `logger.log(:warn, '…')` as an argument — and both answer the same question, compared as symbols.

data/hubbado-log.gemspec

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

data/lib/hubbado/log/controls/log_handler.rb

@@ -8,10 +8,11 @@ module Hubbado
           @messages ||= []
         end
 
-        # Replaces a class's logger with one writing here, keeping its subject. Neither the
-        # configured level nor the configured tags decide what a spec attaching one of these can
-        # read: it is asking what the class said, and the process's filters are not its subject.
-        def self.attach(instance, level: :trace, tags: Tags::ALL)
+        # Replaces a class's logger with one writing here, keeping its subject. This handler
+        # records rather than displays, so the operator's settings do not decide what a spec
+        # attaching one can read: it is asking what the class said, and the process's filters are
+        # not its subject.
+        def self.attach(instance)
           logger = instance.logger
 
           if logger.nil?
@@ -20,24 +21,28 @@ module Hubbado
           end
 
           new.tap do |handler|
-            instance.logger = Log::Logger.new(logger.subject, [handler], level: level, tags: tags)
+            instance.logger = Log::Logger.new(logger.subject, [handler])
           end
         end
 
         # For a class handed a logger rather than carrying one, and for a spec that wants both.
-        def self.logger(subject = Subject.example, level: :trace, tags: Tags::ALL)
+        def self.logger(subject = nil)
+          subject ||= Subject.example
           handler = new
 
-          [handler, Log::Logger.new(subject, [handler], level: level, tags: tags)]
+          [handler, Log::Logger.new(subject, [handler])]
         end
 
-        def log(subject, severity, message, data = nil, stacktrace = nil)
+        def log(subject, severity, message, data = nil, stacktrace = nil, tags = nil)
+          tags ||= []
+
           messages << {
             subject: subject,
             severity: severity,
             message: message,
             data: data,
-            stacktrace: stacktrace
+            stacktrace: stacktrace,
+            tags: tags
           }
         end
 
@@ -57,7 +62,7 @@ module Hubbado
 
         # The most recent message. Derived rather than assigned alongside `messages`, so the two
         # cannot disagree about which message is the latest.
-        %i[subject severity message data stacktrace].each do |field|
+        %i[subject severity message data stacktrace tags].each do |field|
           define_method(field) { messages.last&.fetch(field) }
         end
       end

data/lib/hubbado/log/display.rb

@@ -0,0 +1,17 @@
+module Hubbado
+  class Log
+    # Whether the operator asked to be shown a message. A handler that prints asks this; one that
+    # reports an incident does not, so narrowing a log cannot silence a failure.
+    class Display
+      # Both have to pass: a tag cannot raise a message above the level, nor the level rescue one
+      # the list leaves out.
+      def self.shows?(severity, tags = nil)
+        config = Log.config
+
+        return false if SEVERITIES.fetch(severity.to_sym) < SEVERITIES.fetch(config.level)
+
+        config.tags.write?(tags)
+      end
+    end
+  end
+end

data/lib/hubbado/log/log_handler.rb

@@ -1,7 +1,12 @@
 module Hubbado
   class Log
     class LogHandler
-      def log(_subject, _severity, _msg, _data = nil, _stacktrace = nil)
+      # Whether this handler would use a synthesised stacktrace. Answered before one is made,
+      # because Kernel.caller costs more than the rest of a log call put together. True here, so a
+      # handler written before this existed is asked nothing and keeps what it always had.
+      def traces?(_severity, _tags = nil) = true
+
+      def log(_subject, _severity, _msg, _data = nil, _stacktrace = nil, _tags = nil)
         raise NotImplementedError
       end
     end

data/lib/hubbado/log/logger/substitute.rb

@@ -4,46 +4,65 @@ module Hubbado
       # What a logger was told rather than what it wrote. Extended onto a mimic of Logger, so a
       # class under test is handed something that answers as a logger and keeps what it was given.
       module Substitute
-        Entry = Data.define(:severity, :message, :data)
-
-        # Everything about what a class said, in order. Named with a severity, only what it said
-        # at that one.
-        #
-        # A severity reaches a logger two ways: as the method, from the generated severity
-        # methods, or as #log's first argument. Both are compared as symbols, because #log takes
-        # a String as readily and passes on what it was given.
-        def logged(severity = nil)
+        # One line, as the logger read it rather than as the call site typed it.
+        Entry = Data.define(:severity, :message, :data, :tags) do
+          # As a symbol, because #log takes a String as readily.
+          def at?(name) = severity == name.to_s.to_sym
+
+          # A String names the line in full; a Regexp names enough of it to tell it from the
+          # others, without writing a record id into the spec.
+          def says?(pattern)
+            return pattern.match?(message.to_s) if pattern.is_a?(Regexp)
+
+            message == pattern
+          end
+
+          # Every tag the line carries, and no others. Order is not compared: a call site writes
+          # them in whatever order reads well, and the allow-list never sees one either.
+          def tagged?(names) = tags.uniq.sort == names.uniq.sort
+        end
+
+        # Everything about what a class said, in order, narrowed by whichever criteria a spec
+        # names. Named together, because a run writes several lines and a message and a tag list
+        # asserted apart can each be true of a different one.
+        def logged(severity = nil, message: nil, tags: nil)
           entries = invocations.map { |invocation| entry(invocation) }
 
-          return entries if severity.nil?
+          named = symbols(tags)
 
-          entries.select { |entry| entry.severity == severity.to_s.to_sym }
+          entries = entries.select { |entry| entry.at?(severity) } unless severity.nil?
+          entries = entries.select { |entry| entry.says?(message) } unless message.nil?
+          entries = entries.select { |entry| entry.tagged?(named) } unless tags.nil?
+
+          entries
         end
 
         # What a class said, where #logged is everything about it.
-        def messages(severity = nil) = logged(severity).map(&:message)
+        def messages(...) = logged(...).map(&:message)
 
-        # Whether, where #logged and #messages ask what. Without a severity, whether anything was
-        # written at all.
-        def logged?(severity = nil) = !logged(severity).empty?
+        # Whether, where the two above ask what. Named nothing, whether anything was written.
+        def logged?(...) = !logged(...).empty?
 
         private
 
+        # A severity arrives as the method name, from the generated severity methods, or as #log's
+        # first argument. Both tags keywords land in one list, as the logger lands them, so a spec
+        # does not break when a call site moves between the two.
         def entry(invocation)
           arguments = invocation.arguments
 
+          severity = arguments.fetch(:severity, invocation.method_name)
+
           Entry.new(
-            severity: severity(invocation).to_s.to_sym,
+            severity: severity.to_s.to_sym,
             message: arguments[:msg],
-            data: arguments[:data]
+            data: arguments[:data],
+            tags: symbols(arguments[:tags]) + symbols(arguments[:tag])
           )
         end
 
-        def severity(invocation)
-          return invocation.arguments.fetch(:severity) if invocation.method_name == :log
-
-          invocation.method_name
-        end
+        # One name or a list of them, however a call site or a spec wrote it.
+        def symbols(names) = Array(names).map { |name| name.to_s.to_sym }
       end
     end
   end

data/lib/hubbado/log/logger.rb

@@ -4,31 +4,16 @@ module Hubbado
       attr_accessor :log_handlers
       attr_accessor :subject
 
-      def initialize(subject, log_handlers = [], level: nil, tags: nil)
+      def initialize(subject, log_handlers = nil)
         self.subject = subject
         self.log_handlers = Array(log_handlers)
-        @level = level
-        @tags = tags
       end
 
-      # A logger built without one follows the configuration, which is every logger the gem
-      # builds itself: `Log.configure` names neither, so a class using the Dependency module
-      # takes whatever the process was configured for.
-      def level = @level || Log.config.level
-
-      # Named per logger as well as per process, as the level is and as Eventide's log gem has
-      # it, so one component can be read without turning up everything around it.
-      def tags = @tags.nil? ? Log.config.tags : Tags.parse(@tags)
-
       def log(severity, msg, data = nil, tag: nil, tags: nil)
         unless SEVERITIES.keys.include? severity.to_sym
           raise ArgumentError, "Unknown serverity #{severity}"
         end
 
-        # Read after the severity is checked, never before: the level decides what is printed,
-        # not what may be said, so quietening a logger must not turn a typo into silence.
-        return if SEVERITIES.fetch(severity.to_sym) < SEVERITIES.fetch(level)
-
         # Singular and plural are both accepted and both kept, following Eventide's log gem,
         # where real call sites use either and occasionally hand an array to the singular one.
         #
@@ -36,20 +21,14 @@ module Hubbado
         # match nothing and its message would go missing with nothing said about it.
         message_tags = (Array(tags) + Array(tag)).map { |name| name.to_s.to_sym }
 
-        # Both filters have to pass. A tag cannot raise a message above the level, and the level
-        # cannot rescue one the list leaves out.
-        #
-        # `self.` because the `tags:` keyword above shadows the reader.
-        return unless self.tags.write?(message_tags)
-
         stacktrace = if data.is_a?(Exception)
                        data.full_message
-                     elsif STACKTRACE_SEVERITIES.include?(severity)
+                     elsif traced?(severity, message_tags)
                        format_stacktrace Kernel.caller
                      end
 
         log_handlers.each do |handler|
-          handler.log(subject, severity, msg, data, stacktrace)
+          handler.log(subject, severity, msg, data, stacktrace, message_tags)
         end
       end
 
@@ -61,6 +40,15 @@ module Hubbado
 
       private
 
+      # Kernel.caller is the most expensive thing in a log call, so it is not paid for a message
+      # every handler would drop — or for a warning, which this gem synthesises one for and the
+      # terminal then declines to print.
+      def traced?(severity, message_tags)
+        return false unless STACKTRACE_SEVERITIES.include?(severity.to_sym)
+
+        log_handlers.any? { |handler| handler.traces?(severity, message_tags) }
+      end
+
       def format_stacktrace(stacktrace)
         stacktrace.join("\n")
       end

data/lib/hubbado/log/notify_rollbar.rb

@@ -17,7 +17,9 @@ module Hubbado
         @notifier = notifier
       end
 
-      def log(subject, severity, message, data = nil, stacktrace = nil)
+      def traces?(severity, _tags = nil) = LEVELS.key?(severity.to_sym)
+
+      def log(subject, severity, message, data = nil, stacktrace = nil, _tags = nil)
         level = LEVELS[severity.to_sym]
         return if level.nil?
 

data/lib/hubbado/log/rails_logger.rb

@@ -14,7 +14,11 @@ module Hubbado
         @rails_logger = rails_logger
       end
 
-      def log(subject, severity, message, data = nil, stacktrace = nil)
+      def traces?(severity, tags = nil) = Display.shows?(severity, tags)
+
+      def log(subject, severity, message, data = nil, stacktrace = nil, tags = nil)
+        return unless Display.shows?(severity, tags)
+
         rails_severity = RAILS_SEVERITIES.fetch(severity.to_sym, severity)
 
         rails_logger.send(rails_severity, "#{subject}: #{message}")

data/lib/hubbado/log/stderr_logger.rb

@@ -19,7 +19,14 @@ module Hubbado
       # One write, because a line and the detail under it belong together. Three writes let a
       # second thread put its own line between them, and a stacktrace filed under the wrong
       # message is worse than no stacktrace.
-      def log(subject, severity, message, data = nil, stacktrace = nil)
+      # Only a failure earns one on a terminal, and only if the operator is being shown it.
+      def traces?(severity, tags = nil)
+        FAILURE_SEVERITIES.include?(severity.to_sym) && Display.shows?(severity, tags)
+      end
+
+      def log(subject, severity, message, data = nil, stacktrace = nil, tags = nil)
+        return unless Display.shows?(severity, tags)
+
         lines = ["#{severity.to_s.upcase} #{subject}: #{message}"]
         lines << detail(data, stacktrace) unless data.nil?
         lines << stacktrace if print_stacktrace?(severity, data, stacktrace)

data/lib/hubbado/log/tags.rb

@@ -27,7 +27,7 @@ module Hubbado
 
       attr_reader :tags
 
-      def initialize(tags = [])
+      def initialize(tags = nil)
         @tags = Array(tags).map { |tag| tag.to_s.to_sym }
       end
 

data/lib/hubbado/log.rb

@@ -1,5 +1,6 @@
 require 'dependency'
 require "hubbado/log/tags"
+require "hubbado/log/display"
 require "hubbado/log/configuration"
 require "hubbado/log/log"
 require "hubbado/log/logger"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hubbado-log
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Hubbado Devs
@@ -116,6 +116,7 @@ files:
 - lib/hubbado/log/controls/rollbar.rb
 - lib/hubbado/log/controls/stacktrace.rb
 - lib/hubbado/log/controls/subject.rb
+- lib/hubbado/log/display.rb
 - lib/hubbado/log/log.rb
 - lib/hubbado/log/log_handler.rb
 - lib/hubbado/log/logger.rb