l2meter 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a8758c9423aad4f0d392487036c92d4501e6a8fc
-  data.tar.gz: 14250d1270dabf5f366ee22c7bbab6dff0e8abcf
+SHA256:
+  metadata.gz: 1d6bbc8048445c11b2601b92ad8ff351ef058d842127dd53588e5e78f3219a80
+  data.tar.gz: 186c086e8782a191f32c638f7687008cc7d0cc08dea636a12234092736e826af
 SHA512:
-  metadata.gz: ed94d0f0a82ec17c59e4b57a0598adaac7f0eb6bd2d4662e42bd9ec785a3f563cf56b1ee582bc5fb104b2f676f1ebd161aed76f45ce8c8d37823a8d895a5099b
-  data.tar.gz: c53adc609873409a3a9f5edaf3acce2d6732cc811f347a16764ea3a41cee55b01f96cd2567e6a9b2d1597a64c04e3697c701d4bbb5e0d480b06e4cce59cd0936
+  metadata.gz: 1ec890f4bde056dfe4f85303530e8c8e5a013720778a202bcc81cec6c736ab04d059267c16401bdf1ef0c00b1154163c53f03692d0a87f0811f491880ceedf13
+  data.tar.gz: 98896fb1fa2e8af273168160048d888eac1ebad6bc5725826b873cf1aba0f0cc1b0222986e70ccd8430cd7ec8dca11ff3e1d9408173c5ce7708fa38ce9e09fe3

data/README.md

@@ -1,49 +1,50 @@
 # L2meter
 [![Gem Version](https://img.shields.io/gem/v/l2meter.svg)](https://rubygems.org/gems/l2meter)
-[![Build Status](https://img.shields.io/travis/rwz/l2meter.svg)](http://travis-ci.org/rwz/l2meter)
-[![Code Climate](https://img.shields.io/codeclimate/github/rwz/l2meter.svg)](https://codeclimate.com/github/rwz/l2meter)
+[![Build Status](https://travis-ci.com/heroku/l2meter.svg?branch=master)](http://travis-ci.com/heroku/l2meter)
 
-L2meter is a little gem that helps you build loggers that outputs things in
-l2met-friendly format.
+L2meter is a little gem for building [logfmt]-compatiable loggers.
+
+[logfmt]: https://www.brandur.org/logfmt
 
 ### Basics
 
 A new logger might be created like so:
 
 ```ruby
-Metrics = L2meter.build
+logger = L2meter.build
 ```
 
-If you plan to use it globally across different components of your app,consider
-making it constant.
+Consider making the logger a constant to make it easier to use across different
+components of the app or globally.
 
-The base `log` method accepts two type of things: bare values and key-value
+The base `log` method accepts two type of arguments: bare values and key-value
 pairs in form of hashes.
 
 ```ruby
-Metrics.log "Hello world"                 # => hello-world
-Metrics.log :db_query, result: :success   # => db-query result=success
+logger.log "Hello world"                 # => hello-world
+logger.log :db_query, result: :success   # => db-query result=success
 ```
 
-It can also take a block. In this case the message will be emitted twice, once
-at the start of the execution and another at the end. The end result might look
-like so:
+The method also takes a block. In this case the message will be emitted twice,
+once at the start of the execution and once at the end. The end result might
+look like so:
 
 ```ruby
-Metrics.log :doing_work do            # => doing-work at=start
-  do_some_work                        #
-  Metrics.log :work_done              # => work-done
-end                                   # => doing-work at=finish elapsed=1.2345
+logger.log :doing_work do            # => doing-work at=start
+  do_some_work                       #
+  logger.log :work_done              # => work-done
+end                                  # => doing-work at=finish elapsed=1.2345
 ```
 
-In case the exception is raised inside the block, l2meter will report is like
-so:
+In case of the exception inside the block, all relevant information is logged
+and then exception is re-raised.
 
 ```ruby
-Metrics.log :doing_work do  # => doing-work at=start
+logger.log :doing_work do   # => doing-work at=start
   raise ArgumentError, \    #
     "something is wrong"    #
 end                         # => doing-work at=exception exception=ArgumentError message="something is wrong" elapsed=1.2345
+                            # ArgumentError: something is wrong
 ```
 
 ## Context
@@ -54,7 +55,7 @@ L2meter allows setting context for a block. It might work something like this:
 def do_work_with_retries
   attempt = 1
   begin
-    Metrics.context attempt: attempt do
+    logger.context attempt: attempt do
       do_some_work            # => doing-work attempt=1
                               # => doing-work attempt=2
                               # => doing-work attempt=3
@@ -69,12 +70,12 @@ end
 L2meter supports dynamic contexts as well. You can pass a proc instead of raw
 value in order to use it.
 
-The same example as above could be re-written like this instead:
+The example above could be re-written like this instead:
 
 ```ruby
 def do_work_with_retries
   attempt = 1
-  Metrics.context ->{{ attempt: attempt }} do
+  logger.context ->{{ attempt: attempt }} do
     begin
       do_some_work
     rescue => error
@@ -85,71 +86,73 @@ def do_work_with_retries
 end
 ```
 
-## Contexted logging
-
-Sometimes you want another copy of the logger with a specific context on it.
-You can create one like so:
+It's possbile to create a dedicated copy of the logger with some specific
+context attached to it.
 
 ```ruby
-logger = Metrics.context(:super_worker, username: "joe")
+worker_logger = logger.context(component: :worker, worker_id: 123)
 
-SuperWorker.new(logger: logger).run # => super-worker username=joe some-other=superworker-output
+MyWorker.new(logger: worker_logger).run # => component=worker worker_id=123 status="doing work"
 ```
 
 ## Batching
 
-There's also a way to batch several calls into a single log line:
+There's a way to batch several calls into a single log line:
 
 ```ruby
-Metrics.batch do
-  Metrics.log foo: :bar
-  Metrics.unique :registeration, "user@example.com"
-  Metrics.count :thing, 10
-  Metrics.sample :other_thing, 20
+logger.batch do
+  logger.log foo: :bar
+  logger.unique :registration, "user@example.com"
+  logger.count :thing, 10
+  logger.sample :other_thing, 20
 end # => foo=bar unique#registration=user@example.com count#thing=10 sample#other-thing=20
 ```
 
-## Other
+## Metrics
+
+Some [l2met]-specific metrics are supported.
 
-Some other l2met-specific methods are supported.
+[l2met]: https://r.32k.io/l2met-introduction
 
 ```ruby
-Metrics.count :user_registered             # => count#user-registered=1
-Metrics.count :registered_users, 10        # => count#registered-users=10
+logger.count :user_registered             # => count#user-registered=1
+logger.count :registered_users, 10        # => count#registered-users=10
 
-Metrics.measure :connection_count, 20      # => measure#connection-count=20
-Metrics.measure :db_query, 235, unit: :ms, # => measure#db-query.ms=235
+logger.measure :connection_count, 20      # => measure#connection-count=20
+logger.measure :db_query, 235, unit: :ms, # => measure#db-query.ms=235
 
-Metrics.sample :connection_count, 20,      # => sample#connection-count=235
-Metrics.sample :db_query, 235, unit: :ms,  # => sample#db-query.ms=235
+logger.sample :connection_count, 20,      # => sample#connection-count=235
+logger.sample :db_query, 235, unit: :ms,  # => sample#db-query.ms=235
 
-Metrics.unique :user, "bob@example.com"    # => unique#user=bob@example.com
+logger.unique :user, "bob@example.com"    # => unique#user=bob@example.com
 ```
 
-L2meter also allows to append elapsed time to your log messages automatically.
+## Measuring Time
+
+L2meter allows to append elapsed time to log messages automatically.
 
 ```ruby
-Metrics.with_elapsed do
+logger.with_elapsed do
   do_work_step_1
-  Metrics.log :step_1_done # => step-1-done elapsed=1.2345
+  logger.log :step_1_done # => step-1-done elapsed=1.2345
   do_work_step_2
-  Metrics.log :step_2_done # => step-2-done elapsed=2.3456
+  logger.log :step_2_done # => step-2-done elapsed=2.3456
 end
 ```
 
-### Configuration
+## Configuration
 
-L2meter supports configuration. Here's how you can configure things:
+L2meter supports customizable configuration.
 
 ```ruby
-Metrics = L2meter.build do |config|
+logger = L2meter.build do |config|
   # configuration happens here
 end
 ```
 
-Here's the list of all configurable things:
+Here's the full list of available settings.
 
-#### Global context
+### Global context
 
 Global context works similary to context method, but globally:
 
@@ -158,71 +161,75 @@ config.context = { app_name: "my-app-name" }
 
 # ...
 
-Metrics.log foo: :bar # => app-name=my-app-name foo=bar
+logger.log foo: :bar # => app-name=my-app-name foo=bar
 ```
 
 Dynamic context is also supported:
 
 ```ruby
 config.context do
-  { request_id: CurrentContext.request_id }
+  { request_id: SecureRandom.uuid }
 end
+
+logger.log :hello # => hello request_id=4209ba28-4a7c-40d6-af69-c2c1ddf51f19
+logger.log :world # => world request_id=b6836b1b-5710-4f5f-926d-91ab9988a7c1
 ```
 
-#### Sorting
+### Sorting
 
 By default l2meter doesn't sort tokens before output, putting them in the order
-they're passed. But you can make it sorted like so:
+they're passed. But it's possible to sort them like so:
 
 ```ruby
 config.sort = true
 
 # ...
 
-Metrics.log :c, :b, :a  # => a b c
+logger.log :c, :b, :a  # => a b c
 ```
 
-#### Source
+### Source
 
 Source is a special parameter that'll be appended to all emitted messages.
 
 ```ruby
-config.source = "production"
+config.source = "com.heroku.my-application.staging"
 
 # ...
 
-Metrics.log foo: :bar # => source=production foo=bar
+logger.log foo: :bar # => source=com.heroku.my-application.staging foo=bar
 ```
 
-#### Prefix
+### Prefix
 
-Prefix allows namespacing your measure/count/unique/sample calls.
+Prefix allows to add namespacing to measure/count/unique/sample calls.
 
 ```ruby
 config.prefix = "my-app"
 
 # ...
 
-Metrics.count :users, 100500 # => count#my-app.users=100500
+logger.count :users, 100500 # => count#my-app.users=100500
 ```
 
-## Scrubbing
+### Scrubbing
 
 L2meter allows plugging in custom scrubbing logic that might be useful in
-environments where logging compliance is important.
+environments where logging compliance is important to prevent accidentally
+leaking sensitive information.
 
 ```ruby
-config.scrubber = ->(key, value) do
+config.scrubber = -> (key, value) do
   begin
     uri = URI.parse(value)
-    uri.password = "scrubbed" if uri.password
+    uri.password = "redacted" if uri.password
     uri.to_s
   rescue URI::Error
     value
   end
 end
 
-Metric.log my_url: "https://user:password@example.com"
+logger.log my_url: "https://user:password@example.com"
 # => my-url="https://user:redacted@example.com"
 ```
 
@@ -234,13 +241,13 @@ There's a way to temporary silence the log emitter. This might be userful for
 tests for example.
 
 ```ruby
-Metrics.silence do
+logger.silence do
   # logger is completely silenced
-  Metrics.log "hello world" # nothing is emitted here
+  logger.log "hello world" # nothing is emitted here
 end
 
 # works normally again
-Metrics.log :foo            # => foo
+logger.log :foo            # => foo
 ```
 
 The typical setup for RSpec might look like this:
@@ -248,16 +255,17 @@ The typical setup for RSpec might look like this:
 ```ruby
 RSpec.configure do |config|
   config.around :each do |example|
-    Metrics.silence &example
+    MyLogger.silence &example
   end
 end
 ```
 
-Note that this code will only silence logger in the current thread. It'll still
-produce output if you fire up a new thread. To silence it completely, use
-`disable!` method, like so:
+Note that silence method will only suppress logging in the current thread.
+It'll still produce output if you fire up a new thread. To silence it
+completely, use `disable!` method. This will completely silence the logger
+across all threads.
 
 ```ruby
 # spec/spec_helper.rb
-Metrics.disable!
+MyLogger.disable!
 ```

data/lib/l2meter.rb

@@ -5,12 +5,10 @@ module L2meter
 
   autoload :Configuration, "l2meter/configuration"
   autoload :Emitter,       "l2meter/emitter"
-  autoload :NullObject,    "l2meter/null_object"
-  autoload :ThreadSafe,    "l2meter/thread_safe"
+  autoload :NullOutput,    "l2meter/null_output"
 
   def build(configuration: Configuration.new)
     yield configuration if block_given?
-    emitter = Emitter.new(configuration: configuration.freeze)
-    ThreadSafe.new(emitter)
+    Emitter.new(configuration: configuration.freeze)
   end
 end

data/lib/l2meter/emitter.rb

@@ -1,4 +1,5 @@
 require "time"
+require "thread"
 
 module L2meter
   class Emitter
@@ -6,14 +7,10 @@ module L2meter
 
     def initialize(configuration: Configuration.new)
       @configuration = configuration
-      @buffer = {}
-      @autoflush = true
-      @contexts = []
-      @outputs = []
     end
 
     def log(*args)
-      merge! *current_contexts, *args
+      merge! current_context, *args
 
       if block_given?
         wrap &proc
@@ -22,35 +19,55 @@ module L2meter
       end
     end
 
-    def with_elapsed(start_time = Time.now, &block)
-      context(elapsed_context(start_time), &block)
+    def context(*context_data)
+      if block_given?
+        wrap_context(context_data, &proc)
+      else
+        contexted(context_data)
+      end
     end
 
-    def with_output(output)
-      @outputs.push output
-      yield
-    ensure
-      @outputs.pop
+    def with_elapsed
+      context elapsed: elapse do
+        yield
+      end
     end
 
     def silence
-      with_output(NullObject.new, &proc)
+      with_output(NullOutput.new, &proc)
     end
 
     def silence!
-      @outputs.push NullObject.new
+      set_output NullOutput.new
     end
 
     def unsilence!
-      @outputs.pop
+      set_output nil
     end
 
-    def measure(metric, value, unit: nil)
-      log_with_prefix :measure, metric, value, unit: unit
+    def with_output(new_output)
+      old_output = output
+      set_output new_output
+      yield
+    ensure
+      set_output old_output
     end
 
-    def sample(metric, value, unit: nil)
-      log_with_prefix :sample, metric, value, unit: unit
+    def batch
+      old_state = in_batch?
+      in_batch!
+      yield
+    ensure
+      reset_in_batch old_state
+      write
+    end
+
+    def measure(*args)
+      log_with_prefix :measure, *args
+    end
+
+    def sample(*args)
+      log_with_prefix :sample, *args
     end
 
     def count(metric, value = 1)
@@ -61,167 +78,228 @@ module L2meter
       log_with_prefix :unique, metric, value
     end
 
-    def context(*context_data)
-      return clone_with_context(context_data) unless block_given?
-      push_context context_data
-      yield
-    ensure
-      context_data.length.times { @contexts.pop } if block_given?
+    def clone
+      original_contexts = dynamic_contexts
+      original_output = output
+      self.class.new(configuration: configuration).tap do |clone|
+        clone.instance_eval do
+          dynamic_contexts.concat original_contexts
+          set_output original_output
+        end
+      end
     end
 
-    def clone
-      cloned_contexts = @contexts.clone
-      cloned_outputs = @outputs.clone
-      self.class.new(configuration: configuration).instance_eval do
-        @contexts = cloned_contexts
-        @outputs = cloned_outputs
-        self
+    private
+
+    def log_with_prefix(method, key, value, unit: nil)
+      key = [configuration.prefix, key, unit].compact.join(?.)
+      log Hash["#{method}##{key}", value]
+    end
+
+    def elapse(since = Time.now)
+      -> { Time.now - since }
+    end
+
+    def write(*args)
+      merge! *args
+      fire! unless in_batch?
+    end
+
+    def wrap
+      elapsed = elapse
+      cloned_buffer = buffer.clone
+      write at: :start
+      result, exception = capture(&proc)
+      merge! cloned_buffer
+      if exception
+        write unwrap_exception(exception), elapsed: elapsed
+        raise exception
+      else
+        write at: :finish, elapsed: elapsed
+        result
       end
     end
 
-    def batch
-      autoflush = @autoflush
-      @autoflush = false
+    def capture
+      [yield, nil]
+    rescue Object => exception
+      [nil, exception]
+    end
+
+    def wrap_context(context_data)
+      dynamic_contexts.concat context_data
       yield
     ensure
-      @autoflush = autoflush
-      write
+      context_data.each { dynamic_contexts.pop }
     end
 
-    def merge!(*args)
-      unwrap(args).each do |key, value|
-        key = configuration.key_formatter.call(key)
-        @buffer[key] = value
+    def contexted(context_data)
+      clone.instance_eval do
+        dynamic_contexts.concat context_data
+        self
       end
     end
 
-    def fire!
-      tokens = @buffer.map { |key, value| build_token(key, value) }
-      tokens.compact!
-      tokens.sort! if configuration.sort?
+    def unwrap_exception(exception)
+      {
+        at: :exception,
+        exception: exception.class,
+        message: exception.message
+      }
+    end
 
-      output_queue.last.print tokens.join(SPACE) << NL if tokens.any?
-    ensure
-      @buffer.clear
+    def current_context
+      unwrap(resolved_contexts)
     end
 
-    protected
+    def current_contexts
+      [
+        source_context,
+        configuration.context,
+        *dynamic_contexts
+      ].compact
+    end
 
-    def push_context(context_data)
-      @contexts.concat context_data
+    def source_context
+      { source: configuration.source }
     end
 
-    private
+    def resolved_contexts
+      current_contexts.map { |c| Proc === c ? c.call : c }
+    end
+
+    def fire!
+      tokens = buffer.map { |k, v| build_token(k, v) }.compact
+      tokens.sort! if configuration.sort?
+      return if tokens.empty?
+      output.print tokens.join(SPACE) << NL
+    ensure
+      buffer.clear
+    end
 
     SPACE = " ".freeze
     NL    = "\n".freeze
 
     private_constant :SPACE, :NL
 
-    def unwrap(args)
-      args.each_with_object({}) do |context, result|
-        next if context.nil?
-        context = Hash[context, true] unless Hash === context
-        result.merge! context
-      end
+    def scrub_value(key, value)
+      scrubber = configuration.scrubber
+      scrubber ? scrubber.call(key, value) : value
     end
 
     def build_token(key, value)
-      value = value.call if Proc === value
-      value = scrub_value(key, value)
-      return if value.nil?
-      value == true ? key : "#{key}=#{format_value(value)}"
-    end
-
-    def format_float(value, unit: nil)
-      "%.#{configuration.float_precision}f#{unit}" % value
-    end
-
-    def clone_with_context(context)
-      clone.tap do |emitter|
-        emitter.push_context context
+      case value
+      when Proc
+        build_token(key, value.call)
+      else
+        value = scrub_value(key, value)
+        format_token(key, value)
       end
     end
 
-    def current_contexts
-      contexts_queue.map do |context|
-        context = context.call if context.respond_to?(:call)
-        context
+    def format_token(key, value)
+      case value
+      when TrueClass
+        key
+      when FalseClass, NilClass
+        nil
+      else
+        value = format_value(value)
+        "#{key}=#{value}"
       end
     end
 
     def format_value(value)
       case value
       when Float
-        format_float(value)
+        format_float_value(value)
+      when String
+        format_string_value(value)
       when Time
-        value.iso8601
+        format_time_value(value)
       when Array
         value.map(&method(:format_value)).join(?,)
       else
-        format_string_value(value.to_s)
+        format_value(value.to_s)
       end
     end
 
+    def format_time_value(value)
+      value.iso8601
+    end
+
+    def format_float_value(value)
+      format = "%.#{configuration.float_precision}f"
+      sprintf(format, value)
+    end
+
     def format_string_value(value)
-      value =~ /[^\w,.:@\-\]\[]/ ? value.strip.gsub(/\s+/, " ").inspect : value.to_s
+      value =~ /[^\w,.:@\-\]\[]/ ?
+        value.strip.gsub(/\s+/, " ").inspect :
+        value.to_s
     end
 
-    def write(params = nil)
-      merge! params
-      fire! if @autoflush
+    def merge!(*args)
+      unwrap(args.compact).each do |key, value|
+        key = format_key(key)
+        buffer[key] = value
+      end
     end
 
-    def log_with_prefix(method, key, value, unit: nil)
-      key = [configuration.prefix, key, unit].compact * ?.
-      log Hash["#{method}##{key}", value]
+    def format_key(key)
+      configuration.key_formatter.call(key)
     end
 
-    def wrap
-      start_time = Time.now
-      params = @buffer.clone
-      write at: :start
-      result = exception = nil
-
-      begin
-        result = yield
-        merge! params, at: :finish
-      rescue Object => exception
-        merge! params, \
-          at: :exception,
-          exception: exception.class,
-          message: exception.message
+    def unwrap(args)
+      Hash.new.tap do |result|
+        args.each do |arg|
+          next if arg.nil?
+          arg = Hash[arg, true] unless Hash === arg
+          arg.each do |key, value|
+            result[key] = value
+          end
+        end
       end
+    end
 
-      write elapsed_context(start_time)
+    def thread_state
+      @mutex ||= Mutex.new
+      @mutex.synchronize do
+        @threads ||= {}
 
-      raise exception if exception
+        # cleaning up state from dead threads
+        @threads.delete_if { |t, _| !t.alive? }
 
-      result
+        @threads[Thread.current] ||= {}
+      end
     end
 
-    def contexts_queue
-      [configuration.context, source_context, *@contexts].compact
+    def buffer
+      thread_state[:buffer] ||= {}
     end
 
-    def output_queue
-      [configuration.output, *@outputs].compact
+    def dynamic_contexts
+      thread_state[:dynamic_contexts] ||= []
     end
 
-    def source_context
-      { source: configuration.source }
+    def output
+      thread_state[:output] ||= configuration.output
     end
 
-    def elapsed_context(since = Time.now)
-      { elapsed: -> { Time.now - since } }
+    def set_output(new_output)
+      thread_state[:output] = new_output
     end
 
-    def scrub_value(key, value)
-      if !value.nil? && scrubber = configuration.scrubber
-        scrubber.call(key, value)
-      else
-        value
-      end
+    def in_batch?
+      !!thread_state[:in_batch]
+    end
+
+    def in_batch!
+      reset_in_batch true
+    end
+
+    def reset_in_batch(new_value)
+      thread_state[:in_batch] = new_value
     end
   end
 end

data/lib/l2meter/null_output.rb

@@ -0,0 +1,5 @@
+module L2meter
+  class NullOutput
+    def print(*); end
+  end
+end

data/lib/l2meter/version.rb

@@ -1,3 +1,3 @@
 module L2meter
-  VERSION = "0.12.0".freeze
+  VERSION = "0.13.0".freeze
 end

metadata

@@ -1,15 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: l2meter
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Pavel Pravosud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-07 00:00:00.000000000 Z
-dependencies: []
+date: 2019-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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: 
 email:
 - pavel@pravosud.com
@@ -22,10 +92,9 @@ files:
 - lib/l2meter.rb
 - lib/l2meter/configuration.rb
 - lib/l2meter/emitter.rb
-- lib/l2meter/null_object.rb
-- lib/l2meter/thread_safe.rb
+- lib/l2meter/null_output.rb
 - lib/l2meter/version.rb
-homepage: https://github.com/rwz/l2meter
+homepage: https://github.com/heroku/l2meter
 licenses:
 - MIT
 metadata: {}
@@ -44,8 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: L2met friendly log formatter

data/lib/l2meter/null_object.rb

@@ -1,11 +0,0 @@
-module L2meter
-  class NullObject
-    Emitter.instance_methods(false).each do |method_name|
-      define_method method_name do |*, &block|
-        block && block.call
-      end
-    end
-
-    def print(*); end
-  end
-end

data/lib/l2meter/thread_safe.rb

@@ -1,54 +0,0 @@
-require "forwardable"
-
-module L2meter
-  # This class is a wrapper around Emitter that makes sure that we have a
-  # completely separate clone of Emitter per thread running. It doesn't truly
-  # make Emitter thread-safe, it makes sure that you don't access the same
-  # instance of emitter from different threads.
-  class ThreadSafe
-    extend Forwardable
-
-    def initialize(emitter)
-      @emitter = emitter.freeze
-    end
-
-    def_delegators :receiver, *Emitter.instance_methods(false)
-
-    def context(*args, &block)
-      value = current_emitter.context(*args, &block)
-      Emitter === value ? clone_with_emitter(value) : value
-    end
-
-    def disable!
-      @disabled = true
-    end
-
-    protected
-
-    attr_writer :emitter
-
-    private
-
-    attr_reader :emitter
-
-    def clone_with_emitter(emitter)
-      self.class.new(emitter).tap { |ts| ts.disable! if @disabled }
-    end
-
-    def receiver
-      @disabled ? null_emitter : current_emitter
-    end
-
-    def current_emitter
-      Thread.current[thread_key] ||= emitter.clone
-    end
-
-    def null_emitter
-      @null_emitter ||= NullObject.new
-    end
-
-    def thread_key
-      @thread_key ||= "_l2meter_emitter_#{emitter.object_id}".freeze
-    end
-  end
-end