intake 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: febaaa600f3b7a5c8ed974a8e059a4d5ea12e61b0e5edf6fb0bf3c707f56027b
+  data.tar.gz: 9bc82ce4ad485486a397e63c84c7a54445df78b2e3f285b1d0ec26d1cfddfdc8
+SHA512:
+  metadata.gz: bf360302e2ece8d18034a1b34587d3fa6c8a267f8d13ec64535b7de212e7307235b58b76a28c5f429fed832ee1ef4a1aa05c57391ba5cd74f98d207aa2c71033
+  data.tar.gz: d140b351c1171e9a5bce2e5e4d01926900300f60a8e18ce0c0c591cadcf54ac6ced6fa22b584cf3d8ad4dff754dfc31399613ba39a1b2a8a750869026c430ab1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Andrey Maraev
+
+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,20 @@
+# intake
+
+## Description
+
+**intake** is a powerful and easy to use logging library.
+The library is designed with multiple base principles:
+
+* Be a drop-in replacement for Ruby `Logger`
+* Advanced API to support structured logging
+* Highly efficient non-blocking logger API
+
+## Installation
+
+```shell
+gem install intake
+```
+
+## License
+
+The MIT License. See the [LICENSE](/LICENSE) file for the full text.

data/lib/intake/async_sink.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'immutable/deque'
+
+module Intake
+  # Received events and asynchronously forward events to downstream sink
+  class AsyncSink
+    def initialize(forward_sink)
+      @forward_sink = forward_sink
+      @drain_buffer = Concurrent::AtomicReference.new
+      @drain_buffer.set(Immutable::Deque.empty)
+      @has_events_flag = Concurrent::Event.new
+      @drain_thread = Thread.new { drain_thread_func }
+    end
+
+    def receive(event)
+      @drain_buffer.update { |buffer| buffer.push(event) }
+      @has_events_flag.set
+    end
+
+    protected
+
+    def drain_thread_func
+      @has_events_flag.reset
+
+      loop do
+        @has_events_flag.wait(0.1)
+        @has_events_flag.reset
+
+        drain_backlog(snapshot_backlog)
+      end
+    end
+
+    def snapshot_backlog
+      backlog = nil
+      loop do
+        backlog = @drain_buffer.get
+        break if @drain_buffer.compare_and_set(backlog, Immutable::Deque.empty)
+      end
+      backlog
+    end
+
+    def drain_backlog(backlog)
+      until backlog.empty?
+        e = backlog.first
+        backlog = backlog.shift
+        @forward_sink.receive(e)
+      end
+    end
+  end
+end

data/lib/intake/event_drain.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Intake
+  # EventDrain is a single receiver of messages from loggers. EventDrain forward events to registered sinks
+  class EventDrain
+    include Singleton
+
+    def initialize
+      @sinks = []
+    end
+
+    def add_sink(sink)
+      @sinks << sink
+    end
+
+    def drain(event)
+      @sinks.each { |s| s.receive(event) }
+    end
+
+    def clear_sinks
+      @sinks.clear
+    end
+  end
+end

data/lib/intake/filter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Intake
+  # Filter is a proc-like object that filters events to be accepted by [Intake::Sink]
+  class Filter
+    # Applies filter to the event
+    # @param event [Intake::Event] event to filter
+    # @return [Boolean] true if [Intake::Sink] should accept the event; false otherwise
+    def call(_event)
+      true
+    end
+  end
+end

data/lib/intake/filters/level_filter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../level'
+require_relative '../filter'
+
+module Intake
+  module Filters
+    # Filter by event level. Pass if event level is greater or equal to filter level.
+    class LevelFilter < Filter
+      # Initializes new instance of [Intake::Filters::LevelFilter]
+      # @param limit_level [Intake::Level|Symbol] filter level
+      def initialize(limit_level)
+        super()
+        @limit_level = Intake::Level[limit_level]
+      end
+
+      # Applies filter to the event
+      # @argument event [Intake::Event] event to test
+      # @return [Boolean] true if event pass the filter; false otherwise
+      def call(event)
+        event.level >= @limit_level
+      end
+    end
+  end
+end

data/lib/intake/filters/logger_name_prefix_filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../filter'
+
+module Intake
+  module Filters
+    # Filter event by logger name. Pass if logger name starts with logger prefix.
+    class LoggerNamePrefixFilter < Intake::Filter
+      def initialize(prefix, include_root: true)
+        super()
+        @prefix = prefix
+        @include_root = include_root
+      end
+
+      def call(event)
+        name = event.logger_name
+        (@include_root && name == :root) || name.start_with?(@prefix)
+      end
+    end
+  end
+end

data/lib/intake/formatter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Intake
+  # Base class that serializes event to data format acceptable by sink (usually it's [String])
+  class Formatter
+    def initialize
+      @timestamp_format = '%Y-%m-%dT%H:%M:%S.%6N'
+    end
+
+    def call(event)
+      # rubocop:disable Layout/LineLength
+      "#{event.level.to_s[0]}, [#{event.timestamp.strftime(@timestamp_format)} ##{Process.pid}] #{event.level} -- #{event[:progname]}: #{event.message}\n"
+      # rubocop:enable Layout/LineLength
+    end
+  end
+end

data/lib/intake/io_sink.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'formatter'
+require_relative 'sink'
+
+module Intake
+  # Sink that writes log events to IO stream, e.g., STDOUT or file stream
+  class IOSink < Sink
+    def initialize(io)
+      super()
+      @io = io
+      @formatter = ::Intake::Formatter.new
+    end
+
+    attr_writer :formatter
+
+    def drain(event)
+      txt = @formatter.call(event)
+      @io.write(txt)
+    end
+  end
+end

data/lib/intake/level.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Intake
+  # Log event level.
+  class Level
+    class << self
+      def []=(name, level)
+        (@s ||= {})[name] = level
+      end
+
+      def [](name)
+        (@s ||= {})[name]
+      end
+    end
+
+    attr_reader :name, :val
+
+    def initialize(name, val)
+      @val = val
+      @name = name
+    end
+
+    def to_s
+      @name.to_s.upcase
+    end
+
+    def <(other)
+      @val < other.val
+    end
+
+    def <=(other)
+      @val <= other.val
+    end
+
+    def >(other)
+      @val > other.val
+    end
+
+    def >=(other)
+      @val >= other.val
+    end
+
+    def ==(other)
+      @val == other.val
+    end
+
+    # Define Intake levels
+    [[:debug, 1000], [:info, 2000], [:warn, 3000], [:error, 4000], [:fatal, 5000]].each do |(n, v)|
+      ::Intake::Level[n] = ::Intake::Level.new(n, v).freeze
+    end
+  end
+end

data/lib/intake/log_event.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Intake
+  # Represents a log event.
+  class LogEvent
+    attr_reader :timestamp, :level, :logger_name, :message, :data
+
+    def initialize(timestamp, level, logger_name, msg, meta: nil)
+      @data = (meta || {}).freeze
+      @timestamp = timestamp
+      @level = level
+      @logger_name = logger_name
+      @message = msg
+    end
+
+    def [](key)
+      @data[key]
+    end
+  end
+end

data/lib/intake/logger.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative 'event_drain'
+require_relative 'level'
+require_relative 'log_event'
+require_relative 'mdc'
+require_relative 'repository'
+
+module Intake
+  # Logger is a object that captures log event and forward that to event sinks.
+  class Logger
+    class << self
+      def [](name)
+        ::Intake::Repository.instance.get_or_add(name) do |logger_name|
+          Logger.new(logger_name)
+        end
+      end
+    end
+
+    attr_reader :name
+
+    def initialize(name)
+      validate_name(name)
+
+      @name = name
+      @level = ::Intake::Level[:info]
+    end
+
+    def level?(level)
+      @level.val <= level.val
+    end
+
+    def level=(level)
+      @level = case level
+               when String, Symbol then ::Intake::Level[level.to_sym]
+               when ::Intake::Level then level
+               end
+    end
+
+    %i[debug info warn error fatal].each do |level|
+      code = <<-CODE
+        undef :#{level} if method_defined? :#{level}
+        LEVEL_#{level} = ::Intake::Level[:#{level}]
+
+        def #{level}(msg = nil, meta: nil, error: nil, &block)
+          log_event(LEVEL_#{level}, msg, meta: meta, error: error, &block)
+        end
+      CODE
+      class_eval(code)
+    end
+
+    def log_event(level, msg = nil, meta: nil, error: nil)
+      return false unless level?(level)
+
+      msg = yield if msg.nil? && block_given?
+      meta ||= {}
+      meta[:error] = error unless error.nil?
+      meta.merge!(MDC.items) if MDC.any?
+      event = ::Intake::LogEvent.new(Time.now, level, @name, msg, meta: meta)
+      dispatch_event event
+    end
+
+    private
+
+    def validate_name(name)
+      case name
+      when String
+        raise ArgumentError, 'logger name must not be empty' if name.empty?
+      else
+        raise ArgumentError, 'logger name must be a string'
+      end
+    end
+
+    def dispatch_event(event)
+      EventDrain.instance.drain(event)
+    end
+  end
+end

data/lib/intake/mdc.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Intake
+  # Mapped Diagnostic Context (MDC) is thread-aware Hash-like storage to add extra context details to logged events.
+  module MDC
+    SYNC_MUTEX = Mutex.new
+
+    class << self
+      def []=(key, value)
+        context[key] = value
+      end
+
+      def clear(key)
+        context.delete(key)
+        nil
+      end
+
+      def store(key, value)
+        MDC[key] = value
+      end
+
+      def any?
+        context.any?
+      end
+
+      def items
+        context.dup.freeze
+      end
+
+      private
+
+      def context
+        if Thread.current[:intake_mdc].nil?
+          SYNC_MUTEX.synchronize do
+            Thread.current[:intake_mdc] = {} if Thread.current[:intake_mdc].nil?
+          end
+        end
+        Thread.current[:intake_mdc]
+      end
+    end
+  end
+end

data/lib/intake/repository.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Intake
+  # Repository stores references to loggers by logger name.
+  class Repository
+    include Singleton
+
+    # Initializes new instance of [Intake] class.
+    def initialize
+      @store = {}
+      @mutex = Mutex.new
+    end
+
+    # Tests if logger with given name exists
+    # @return [Boolean] true if logger exists; false otherwise.
+    def key?(name)
+      @store.key? canonize_name(name)
+    end
+
+    def get_or_add(name)
+      name = canonize_name(name)
+      logger = @store[name]
+
+      if logger.nil?
+        logger = @mutex.synchronize do
+          @store[name] = yield(name) unless @store.key?(name)
+          @store[name]
+        end
+      end
+      logger
+    end
+
+    private
+
+    def canonize_name(name)
+      case name
+      when :root, 'root' then 'root'
+      when String then name
+      when Symbol then name.to_s
+      when Module then module_name(name)
+      when Object then module_name(name.class)
+      end
+    end
+
+    def module_name(mod)
+      mod.name
+    end
+  end
+end

data/lib/intake/ruby_logger_adapter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require_relative 'level'
+require_relative 'logger'
+
+module Intake
+  # Logger is a object that captures log event and forward that to event sinks.
+  class Logger
+    def as_ruby_logger(progname: nil)
+      RubyLoggerAdapter.new(self, progname)
+    end
+  end
+
+  # Adapter for [Intake::Logger] to match [::Logger] interface.
+  class RubyLoggerAdapter
+    [
+      [::Logger::DEBUG, ::Intake::Level[:debug]],
+      [::Logger::INFO, ::Intake::Level[:info]],
+      [::Logger::WARN, ::Intake::Level[:warn]],
+      [::Logger::ERROR, ::Intake::Level[:error]],
+      [::Logger::FATAL, ::Intake::Level[:fatal]],
+      [::Logger::UNKNOWN, ::Intake::Level[:fatal]]
+    ].each do |(n, v)|
+      ::Intake::Level[n] = v
+    end
+
+    %i[DEBUG INFO WARN ERROR FATAL UNKNOWN].each do |l|
+      code = <<-CODE
+        LEVEL_#{l} = ::Intake::Level[::Logger::Severity::#{l}]
+
+        def #{l.downcase}(progname = nil, &block)
+          log_event(LEVEL_#{l}, nil, progname, &block)
+        end
+      CODE
+      class_eval(code)
+    end
+
+    def initialize(logger, progname)
+      @progname = progname
+      @logger = logger
+      @meta = { progname: @progname }
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      severity = ::Intake::Level[severity] unless severity.is_a? ::Intake::Level
+      log_event(severity, message, progname, &block)
+    end
+
+    private
+
+    def log_event(severity, message, progname, &block)
+      return true unless @logger.level?(severity)
+
+      progname = @progname if progname.nil?
+
+      if message.nil? && block.nil?
+        message = progname
+        progname = @progname
+      end
+
+      meta = progname == @progname ? @meta : { progname: progname }
+      @logger.log_event(severity, message, meta: meta, &block)
+      true
+    end
+  end
+end

data/lib/intake/sink.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'filter'
+
+module Intake
+  # Sink receives log event and writes to a permanent storage.
+  class Sink
+    def initialize
+      @filters = []
+    end
+
+    def flush
+      @has_events_flag.set if @thread_model == :dedicated_thread
+    end
+
+    def receive(event)
+      return unless accept_event?(event)
+
+      drain event
+    end
+
+    def add_filter(filter)
+      @filters << filter
+    end
+
+    # Receives a message and write to a permanent storage
+    def drain(_event)
+      nil
+    end
+
+    protected
+
+    def accept_event?(event)
+      proceed = true
+      @filters.each do |f|
+        proceed &&= f.call(event)
+        break unless proceed
+      end
+      proceed
+    end
+  end
+end

data/lib/intake/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Intake
+  VERSION = '0.1.0'
+end

data/lib/intake.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'intake/async_sink'
+require_relative 'intake/io_sink'
+require_relative 'intake/logger'
+require_relative 'intake/version'
+require_relative 'intake/filters/level_filter'
+require_relative 'intake/filters/logger_name_prefix_filter'
+
+# Public API module of intake logger
+module Intake
+  def self.[](logger_name)
+    Intake::Logger[logger_name]
+  end
+
+  def self.add_sink(sink)
+    Intake::EventDrain.instance.add_sink sink
+  end
+
+  def self.clear_sinks
+    Intake::EventDrain.instance.clear_sinks
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: intake
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrey Maraev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby-ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: immutable-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: code-scanning-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+description:
+email:
+- the_vk@thevk.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/intake.rb
+- lib/intake/async_sink.rb
+- lib/intake/event_drain.rb
+- lib/intake/filter.rb
+- lib/intake/filters/level_filter.rb
+- lib/intake/filters/logger_name_prefix_filter.rb
+- lib/intake/formatter.rb
+- lib/intake/io_sink.rb
+- lib/intake/level.rb
+- lib/intake/log_event.rb
+- lib/intake/logger.rb
+- lib/intake/mdc.rb
+- lib/intake/repository.rb
+- lib/intake/ruby_logger_adapter.rb
+- lib/intake/sink.rb
+- lib/intake/version.rb
+homepage: https://github.com/the-vk/intake
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+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: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Powerful and extensible logging library
+test_files: []