dry-logger 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 343929c403f114dcb22a13c0406ef82982800e9bed8e58d483a86ab3442d7f13
+  data.tar.gz: 2a224fba0dc7f8d5771219ba0bee0eef0322cefe11e14fbb49ca066319e68bca
+SHA512:
+  metadata.gz: e945a3fde7a2bc2fb8731ae46aabac59df1c8da6208d125d09759af04cc848f5b09453c66b7f65da49ecc79094809ea76746c1610b25f47980833965f43a8037
+  data.tar.gz: 7af951d7152c84f8dbbec03a2c57bbd527b10791a39d585597885378036e823594b5d9b50754b765a445811fc46c3fb34d546a7c33a3a75f8de60b70bad90b88

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+<!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
+
+## 1.0.0.rc1 2022-11-07
+
+This is a port of the original Hanami logger from hanami-utils extended with support for logging
+dispatchers that can log to different destinations.
+
+
+### Added
+
+- Support for providing a string template for log entries via `template` option (via #7) (@solnic)
+- `:rack` string log formatter which inlines request info and displays params at the end (@solnic)
+- Conditional log dispatch via `#log_if` backend's predicate (via #9) (@solnic)
+- Add support for shared context and tagged log entries (via #10) (@solnic)

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2022 dry-rb team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+<!--- this file is synced from dry-rb/template-gem project -->
+[gem]: https://rubygems.org/gems/dry-logger
+[actions]: https://github.com/dry-rb/dry-logger/actions
+[codacy]: https://www.codacy.com/gh/dry-rb/dry-logger
+[chat]: https://dry-rb.zulipchat.com
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-logger
+
+# dry-logger [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
+
+[![Gem Version](https://badge.fury.io/rb/dry-logger.svg)][gem]
+[![CI Status](https://github.com/dry-rb/dry-logger/workflows/ci/badge.svg)][actions]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/5aae4837b97044cfa4537f083ad584e9)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/5aae4837b97044cfa4537f083ad584e9)][codacy]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-logger.svg?branch=main)][inchpages]
+
+## Links
+
+* [User documentation](https://dry-rb.org/gems/dry-logger)
+* [API documentation](http://rubydoc.info/gems/dry-logger)
+
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
+
+* MRI `>= 2.7.0`
+* jruby `>= 9.3` (postponed until 2.7 is supported)
+
+## License
+
+See `LICENSE` file.

data/dry-logger.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# this file is synced from dry-rb/template-gem project
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dry/logger/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dry-logger"
+  spec.authors       = ["Luca Guidi"]
+  spec.email         = ["me@lucaguidi.com"]
+  spec.license       = "MIT"
+  spec.version       = Dry::Logger::VERSION.dup
+
+  spec.summary       = "Logging for Ruby"
+  spec.description   = spec.summary
+  spec.homepage      = "https://dry-rb.org/gems/dry-logger"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-logger.gemspec", "lib/**/*"]
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-logger/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-logger"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-logger/issues"
+
+  spec.required_ruby_version = ">= 3.0"
+
+  # to update dependencies edit project.yml
+
+  spec.add_development_dependency "rspec"
+end

data/lib/dry/logger/backends/file.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "dry/logger/backends/stream"
+
+module Dry
+  module Logger
+    module Backends
+      class File < Stream
+        def initialize(stream:, **opts)
+          Pathname(stream).dirname.mkpath
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/backends/io.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "dry/logger/backends/stream"
+
+module Dry
+  module Logger
+    module Backends
+      class IO < Stream
+        def close
+          super unless stream.equal?($stdout)
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/backends/stream.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "logger"
+
+require "dry/logger/constants"
+
+module Dry
+  module Logger
+    module Backends
+      class Stream < ::Logger
+        # @since 0.1.0
+        # @api private
+        attr_reader :stream
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :level
+
+        # @since 0.1.0
+        # @api public
+        attr_accessor :log_if
+
+        # @since 0.1.0
+        # @api private
+        def initialize(stream:, formatter:, level: DEFAULT_LEVEL, progname: nil, log_if: nil)
+          super(stream, progname: progname)
+
+          @stream = stream
+          @level = LEVELS[level]
+
+          self.log_if = log_if
+          self.formatter = formatter
+        end
+
+        # @since 1.0.0
+        # @api private
+        def log?(entry)
+          if log_if
+            log_if.call(entry)
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/constants.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Dry
+  module Logger
+    LOG_METHODS = %i[debug error fatal info warn].freeze
+
+    BACKEND_METHODS = %i[close].freeze
+
+    DEBUG = ::Logger::DEBUG
+    INFO = ::Logger::INFO
+    WARN = ::Logger::WARN
+    ERROR = ::Logger::ERROR
+    FATAL = ::Logger::FATAL
+    UNKNOWN = ::Logger::UNKNOWN
+
+    LEVEL_RANGE = (DEBUG..UNKNOWN).freeze
+
+    DEFAULT_LEVEL = INFO
+
+    # @since 0.1.0
+    # @api private
+    LEVELS = Hash
+      .new { |levels, key|
+        LEVEL_RANGE.include?(key) ? key : levels.fetch(key.to_s.downcase, DEFAULT_LEVEL)
+      }
+      .update(
+        "debug" => DEBUG,
+        "info" => INFO,
+        "warn" => WARN,
+        "error" => ERROR,
+        "fatal" => FATAL,
+        "unknown" => UNKNOWN
+      )
+      .freeze
+
+    DEFAULT_OPTS = {level: DEFAULT_LEVEL, formatter: nil, progname: nil}.freeze
+
+    BACKEND_OPT_KEYS = DEFAULT_OPTS.keys.freeze
+    FORMATTER_OPT_KEYS = %i[filter].freeze
+  end
+end

data/lib/dry/logger/dispatcher.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "logger"
+require "pathname"
+
+require "dry/logger/constants"
+require "dry/logger/entry"
+
+module Dry
+  module Logger
+    # Logger dispatcher routes log entries to configured logging backends
+    #
+    # @since 1.0.0
+    # @api public
+    class Dispatcher
+      # @since 1.0.0
+      # @api private
+      attr_reader :id
+
+      # (EXPERIMENTAL) Shared payload context
+      #
+      # @example
+      #   logger.context[:component] = "test"
+      #
+      #   logger.info "Hello World"
+      #   # Hello World component=test
+      #
+      # @since 1.0.0
+      # @api public
+      attr_reader :context
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :backends
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :options
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :mutex
+
+      # Set up a dispatcher
+      #
+      # @since 1.0.0
+      #
+      # @param [String, Symbol] id The dispatcher id, can be used as progname in log entries
+      # @param [Hash] options Options that can be used for both the backend and formatter
+      #
+      # @return [Dispatcher]
+      # @api public
+      def self.setup(id, **options)
+        dispatcher = new(id, **DEFAULT_OPTS, **options)
+        dispatcher.add_backend if dispatcher.backends.empty?
+        dispatcher
+      end
+
+      # @since 1.0.0
+      # @api private
+      def self.default_context
+        Thread.current[:__dry_logger__] ||= {}
+      end
+
+      # @since 1.0.0
+      # @api private
+      def initialize(id, backends: [], context: self.class.default_context, **options)
+        @id = id
+        @backends = backends
+        @options = {**options, progname: id}
+        @mutex = Mutex.new
+        @context = context
+      end
+
+      # Log an entry with UNKNOWN severity
+      #
+      # @see Dispatcher#log
+      # @api public
+      # @return [true]
+      def unknown(message = nil, **payload)
+        log(:unknown, message, **payload)
+      end
+
+      # Log an entry with DEBUG severity
+      #
+      # @see Dispatcher#log
+      # @api public
+      # @return [true]
+      def debug(message = nil, **payload)
+        log(:debug, message, **payload)
+      end
+
+      # Log an entry with INFO severity
+      #
+      # @see Dispatcher#log
+      # @api public
+      # @return [true]
+      def info(message = nil, **payload)
+        log(:info, message, **payload)
+      end
+
+      # Log an entry with WARN severity
+      #
+      # @see Dispatcher#log
+      # @api public
+      # @return [true]
+      def warn(message = nil, **payload)
+        log(:warn, message, **payload)
+      end
+
+      # Log an entry with ERROR severity
+      #
+      # @see Dispatcher#log
+      # @api public
+      # @return [true]
+      def error(message = nil, **payload)
+        log(:error, message, **payload)
+      end
+
+      # Log an entry with FATAL severity
+      #
+      # @see Dispatcher#log
+      # @api public
+      # @return [true]
+      def fatal(message = nil, **payload)
+        log(:fatal, message, **payload)
+      end
+
+      BACKEND_METHODS.each do |name|
+        define_method(name) do
+          call(name)
+        end
+      end
+
+      # Return severity level
+      #
+      # @since 1.0.0
+      # @return [Integer]
+      # @api public
+      def level
+        LEVELS[options[:level]]
+      end
+
+      # Pass logging to all configured backends
+      #
+      # @param [Symbol] severity The log severity name
+      # @param [String,Symbol,Array] message Optional message object
+      # @param [Hash] payload Optional log entry payload
+      #
+      # @since 1.0.0
+      # @return [true]
+      # @api public
+      def log(severity, message = nil, **payload)
+        case message
+        when Hash then log(severity, nil, **message)
+        else
+          entry = Entry.new(
+            progname: id,
+            severity: severity,
+            message: message,
+            payload: {**context, **payload}
+          )
+
+          each_backend { |backend| backend.__send__(severity, entry) if backend.log?(entry) }
+        end
+
+        true
+      end
+
+      # (EXPERIMENTAL) Tagged logging withing the provided block
+      #
+      # @example
+      #   logger.tagged("red") do
+      #     logger.info "Hello World"
+      #     # Hello World tag=red
+      #   end
+      #
+      #   logger.info "Hello Again"
+      #   # Hello Again
+      #
+      # @since 1.0.0
+      # @api public
+      def tagged(tag)
+        context[:tag] = tag
+        yield
+      ensure
+        context.delete(:tag)
+      end
+
+      # Add a new backend to an existing dispatcher
+      #
+      # @example
+      #   logger.add_backend(template: "ERROR: %<message>s") { |b|
+      #     b.log_if = -> entry { entry.error? }
+      #   }
+      #
+      # @since 1.0.0
+      # @return [Dispatcher]
+      # @api public
+      def add_backend(instance = nil, **backend_options)
+        backend = instance || Dry::Logger.new(**options, **backend_options)
+        yield(backend) if block_given?
+        backends << backend
+        self
+      end
+
+      # @since 1.0.0
+      # @api private
+      def each_backend(*_args, &block)
+        mutex.synchronize do
+          backends.each(&block)
+        end
+      end
+
+      # Pass logging to all configured backends
+      #
+      # @since 1.0.0
+      # @return [true]
+      # @api private
+      def call(meth, ...)
+        each_backend { |backend| backend.public_send(meth, ...) }
+        true
+      end
+    end
+  end
+end

data/lib/dry/logger/entry.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "time"
+require "dry/logger/constants"
+
+module Dry
+  module Logger
+    # @since 1.0.0
+    # @api public
+    class Entry
+      include Enumerable
+
+      # @since 1.0.0
+      # @api private
+      EMPTY_PAYLOAD = {}.freeze
+
+      # @since 1.0.0
+      # @api private
+      EMPTY_BACKTRACE = [].freeze
+
+      # @since 1.0.0
+      # @api public
+      attr_reader :progname
+
+      # @since 1.0.0
+      # @api public
+      attr_reader :severity
+
+      # @since 1.0.0
+      # @api public
+      attr_reader :level
+
+      # @since 1.0.0
+      # @api public
+      attr_reader :time
+
+      # @since 1.0.0
+      # @api public
+      attr_reader :message
+      alias_method :exception, :message
+
+      # @since 1.0.0
+      # @api public
+      attr_reader :payload
+
+      # @since 1.0.0
+      # @api private
+      def initialize(progname:, severity:, time: Time.now, message: nil, payload: EMPTY_PAYLOAD)
+        @progname = progname
+        @severity = severity.to_s.upcase # TODO: this doesn't feel right
+        @level = LEVELS.fetch(severity.to_s)
+        @time = time
+        @message = message
+        @payload = build_payload(payload)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def each(&block)
+        payload.each(&block)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def [](name)
+        payload[name]
+      end
+
+      # @since 1.0.0
+      # @api public
+      def debug?
+        level.equal?(DEBUG)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def info?
+        level.equal?(INFO)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def warn?
+        level.equal?(WARN)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def error?
+        level.equal?(ERROR)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def fatal?
+        level.equal?(FATAL)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def exception?
+        message.is_a?(Exception)
+      end
+
+      # @since 1.0.0
+      # @api public
+      def key?(name)
+        payload.key?(name)
+      end
+
+      # @since 1.0.0
+      # @api private
+      def to_h
+        @to_h ||= meta.merge(payload)
+      end
+
+      # @since 1.0.0
+      # @api private
+      def meta
+        @meta ||= {progname: progname, severity: severity, time: time}
+      end
+
+      # @since 1.0.0
+      # @api private
+      def utc_time
+        @utc_time ||= time.utc.iso8601
+      end
+
+      # @since 1.0.0
+      # @api private
+      def as_json
+        # TODO: why are we enforcing UTC in JSON but not in String?
+        @as_json ||= to_h.merge(message: message, time: utc_time).compact
+      end
+
+      # @since 1.0.0
+      # @api private
+      def filter(filter)
+        @payload = filter.call(payload)
+        self
+      end
+
+      private
+
+      # @since 1.0.0
+      # @api private
+      def build_payload(payload)
+        if exception?
+          {message: exception.message,
+           backtrace: exception.backtrace || EMPTY_BACKTRACE,
+           error: exception.class,
+           **payload}
+        else
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/filter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Dry
+  module Logger
+    # Filtering logic
+    # Originaly copied from hanami/utils (see Hanami::Logger)
+    #
+    # @since 0.1.0
+    # @api private
+    class Filter
+      # @since 0.1.0
+      # @api private
+      def initialize(filters = [])
+        @filters = filters
+      end
+
+      # @since 0.1.0
+      # @api private
+      def call(hash)
+        _filtered_keys(hash).each do |key|
+          *keys, last = _actual_keys(hash, key.split("."))
+          keys.inject(hash, :fetch)[last] = "[FILTERED]"
+        end
+
+        hash
+      end
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      attr_reader :filters
+
+      # @since 0.1.0
+      # @api private
+      def _filtered_keys(hash)
+        _key_paths(hash).select { |key|
+          filters.any? { |filter|
+            key =~ /(\.|\A)#{filter}(\.|\z)/
+          }
+        }
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _key_paths(hash, base = nil)
+        hash.inject([]) do |results, (k, v)|
+          results + (_key_paths?(v) ? _key_paths(v, _build_path(base, k)) : [_build_path(base, k)])
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _build_path(base, key)
+        [base, key.to_s].compact.join(".")
+      end
+
+      # @since 0.1.0
+      # @api private
+      def _actual_keys(hash, keys)
+        search_in = hash
+
+        keys.inject([]) do |res, key|
+          correct_key = search_in.key?(key.to_sym) ? key.to_sym : key
+          search_in = search_in[correct_key]
+          res + [correct_key]
+        end
+      end
+
+      # Check if the given value can be iterated (`Enumerable`) and that isn't a `File`.
+      # This is useful to detect closed `Tempfiles`.
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see https://github.com/hanami/utils/pull/342
+      def _key_paths?(value)
+        value.is_a?(Enumerable) && !value.is_a?(File)
+      end
+    end
+  end
+end

data/lib/dry/logger/formatters/json.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+require "dry/logger/formatters/structured"
+
+module Dry
+  module Logger
+    module Formatters
+      # JSON formatter.
+      #
+      # This formatter returns log entries in JSON format.
+      #
+      # @since 0.1.0
+      # @api public
+      class JSON < Structured
+        # @since 0.1.0
+        # @api private
+        def format(entry)
+          "#{::JSON.generate(entry.as_json)}#{NEW_LINE}"
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/formatters/rack.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "dry/logger/formatters/structured"
+
+module Dry
+  module Logger
+    module Formatters
+      # Special handling of `:params` in the log entry payload
+      #
+      # @since 1.0.0
+      # @api private
+      #
+      # @see String
+      class Rack < String
+        # @since 1.0.0
+        # @api private
+        def format_entry(entry)
+          [*entry.payload.except(:params).values, entry[:params]].compact.join(SEPARATOR)
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/formatters/string.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "dry/logger/formatters/structured"
+
+module Dry
+  module Logger
+    module Formatters
+      # Basic string formatter.
+      #
+      # This formatter returns log entries in key=value format.
+      #
+      # @since 1.0.0
+      # @api public
+      class String < Structured
+        # @since 1.0.0
+        # @api private
+        SEPARATOR = " "
+
+        # @since 1.0.0
+        # @api private
+        HASH_SEPARATOR = ","
+
+        # @since 1.0.0
+        # @api private
+        EXCEPTION_SEPARATOR = ": "
+
+        # @since 1.0.0
+        # @api private
+        DEFAULT_TEMPLATE = "%<message>s"
+
+        # @since 1.0.0
+        # @api private
+        attr_reader :template
+
+        # @since 1.0.0
+        # @api private
+        def initialize(template: DEFAULT_TEMPLATE, **options)
+          super(**options)
+          @template = template
+        end
+
+        private
+
+        # @since 1.0.0
+        # @api private
+        def format(entry)
+          "#{template % entry.meta.merge(message: format_entry(entry))}#{NEW_LINE}"
+        end
+
+        # @since 1.0.0
+        # @api private
+        def format_entry(entry)
+          if entry.exception?
+            format_exception(entry)
+          elsif entry.message
+            if entry.payload.empty?
+              entry.message
+            else
+              "#{entry.message}#{SEPARATOR}#{format_payload(entry)}"
+            end
+          else
+            format_payload(entry)
+          end
+        end
+
+        # @since 1.0.0
+        # @api private
+        def format_exception(entry)
+          hash = entry.payload
+          message = hash.values_at(:error, :message).compact.join(EXCEPTION_SEPARATOR)
+          "#{message}#{NEW_LINE}#{hash[:backtrace].map { |line| "from #{line}" }.join(NEW_LINE)}"
+        end
+
+        # @since 1.0.0
+        # @api private
+        def format_payload(entry)
+          entry.map { |key, value| "#{key}=#{value.inspect}" }.join(HASH_SEPARATOR)
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/formatters/structured.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "logger"
+require "dry/logger/filter"
+
+module Dry
+  module Logger
+    module Formatters
+      # Default structured formatter which receives {Logger::Entry} from the backends.
+      #
+      # @see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger/Formatter.html
+      #
+      # @since 1.0.0
+      # @api public
+      class Structured < ::Logger::Formatter
+        # @since 1.0.0
+        # @api private
+        DEFAULT_FILTERS = [].freeze
+
+        # @since 1.0.0
+        # @api private
+        NOOP_FILTER = -> message { message }
+
+        # @since 1.0.0
+        # @api private
+        NEW_LINE = $/ # rubocop:disable Style/SpecialGlobalVars
+
+        # @since 1.0.0
+        # @api private
+        attr_reader :filter
+
+        # @since 1.0.0
+        # @api private
+        attr_reader :options
+
+        # @since 1.0.0
+        # @api private
+        def initialize(filters: DEFAULT_FILTERS, **options)
+          super()
+          @filter = filters.equal?(DEFAULT_FILTERS) ? NOOP_FILTER : Filter.new(filters)
+          @options = options
+        end
+
+        # Filter and then format the log entry into a string
+        #
+        # Custom formatters typically won't have to override this method because
+        # the actual formatting logic is implemented as Structured#format
+        #
+        # @see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger/Formatter.html#method-i-call
+        #
+        # @since 1.0.0
+        # @return [String]
+        # @api public
+        def call(_severity, _time, _progname, entry)
+          format(entry.filter(filter))
+        end
+
+        # Format entry into a loggable object
+        #
+        # Custom formatters should override this method
+        #
+        # @api since 1.0.0
+        # @return [Entry]
+        # @api public
+        def format(entry)
+          entry
+        end
+      end
+    end
+  end
+end

data/lib/dry/logger/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module Logger
+    VERSION = "1.0.0.rc1"
+  end
+end

data/lib/dry/logger.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "dry/logger/constants"
+require "dry/logger/dispatcher"
+
+require "dry/logger/formatters/string"
+require "dry/logger/formatters/rack"
+require "dry/logger/formatters/json"
+
+require "dry/logger/backends/io"
+require "dry/logger/backends/file"
+
+module Dry
+  # Set up a logger dispatcher
+  #
+  # @example Basic $stdout string logger
+  #   logger = Dry.Logger(:my_app)
+  #
+  #   logger.info("Hello World!")
+  #   # Hello World!
+  #
+  # @example Customized $stdout string logger
+  #   logger = Dry.Logger(:my_app, template: "[%<severity>][%<time>s] %<message>s")
+  #
+  #   logger.info("Hello World!")
+  #   # [INFO][2022-11-06 10:55:12 +0100] Hello World!
+  #
+  #   logger.info(Hello: "World!")
+  #   # [INFO][2022-11-06 10:55:14 +0100] Hello="World!"
+  #
+  #   logger.warn("Ooops!")
+  #   # [WARN][2022-11-06 10:55:57 +0100] Ooops!
+  #
+  #   logger.error("Gaaah!")
+  #   # [ERROR][2022-11-06 10:55:57 +0100] Gaaah!
+  #
+  # @example Basic $stdout JSON logger
+  #   logger = Dry.Logger(:my_app, formatter: :json)
+  #
+  #   logger.info(Hello: "World!")
+  #   # {"progname":"my_app","severity":"INFO","time":"2022-11-06T10:11:29Z","Hello":"World!"}
+  #
+  # @since 1.0.0
+  # @return [Dispatcher]
+  # @api public
+  def self.Logger(id, **opts, &block)
+    Logger::Dispatcher.setup(id, **opts, &block)
+  end
+
+  module Logger
+    # Register a new formatter
+    #
+    # @example
+    #   class MyFormatter < Dry::Logger::Formatters::Structured
+    #     def format(entry)
+    #       "WOAH: #{entry.message}"
+    #     end
+    #   end
+    #
+    #   Dry::Logger.register_formatter(MyFormatter)
+    #
+    # @since 1.0.0
+    # @return [Hash]
+    # @api public
+    def self.register_formatter(name, formatter)
+      formatters[name] = formatter
+      formatters
+    end
+
+    # Build a logging backend instance
+    #
+    # @since 1.0.0
+    # @return [Backends::Stream]
+    # @api private
+    def self.new(stream: $stdout, **opts)
+      backend =
+        case stream
+        when IO, StringIO then Backends::IO
+        when String, Pathname then Backends::File
+        else
+          raise ArgumentError, "unsupported stream type #{stream.class}"
+        end
+
+      formatter_opt = opts[:formatter]
+
+      formatter =
+        case formatter_opt
+        when Symbol then formatters.fetch(formatter_opt).new(**opts)
+        when Class then formatter_opt.new(**opts)
+        when NilClass then formatters[:string].new(**opts)
+        when ::Logger::Formatter then formatter_opt
+        else
+          raise ArgumentError, "unsupported formatter option #{formatter_opt.inspect}"
+        end
+
+      backend_opts = opts.select { |key, _| BACKEND_OPT_KEYS.include?(key) }
+
+      backend.new(stream: stream, **backend_opts, formatter: formatter)
+    end
+
+    # Internal formatters registry
+    #
+    # @since 1.0.0
+    # @api private
+    def self.formatters
+      @formatters ||= {}
+    end
+
+    register_formatter(:string, Formatters::String)
+    register_formatter(:rack, Formatters::Rack)
+    register_formatter(:json, Formatters::JSON)
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: dry-logger
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Luca Guidi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Logging for Ruby
+email:
+- me@lucaguidi.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- dry-logger.gemspec
+- lib/dry/logger.rb
+- lib/dry/logger/backends/file.rb
+- lib/dry/logger/backends/io.rb
+- lib/dry/logger/backends/stream.rb
+- lib/dry/logger/constants.rb
+- lib/dry/logger/dispatcher.rb
+- lib/dry/logger/entry.rb
+- lib/dry/logger/filter.rb
+- lib/dry/logger/formatters/json.rb
+- lib/dry/logger/formatters/rack.rb
+- lib/dry/logger/formatters/string.rb
+- lib/dry/logger/formatters/structured.rb
+- lib/dry/logger/version.rb
+homepage: https://dry-rb.org/gems/dry-logger
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  changelog_uri: https://github.com/dry-rb/dry-logger/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/dry-rb/dry-logger
+  bug_tracker_uri: https://github.com/dry-rb/dry-logger/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Logging for Ruby
+test_files: []