l2meter 0.11.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e11fd798f796a3a70084ef2989c0f3d233d55d7f
-  data.tar.gz: 57141bec2eaee516c4913432720d653f52c3009a
+SHA256:
+  metadata.gz: 3863cb0c00c39be864ceba6afde2364cc8ce88d5c2bbeeaa05c1525110c8ef92
+  data.tar.gz: 9320a7a9e92487406a3bc81d7d784d7c92b6735203a65c368cc8ad7ce69aa007
 SHA512:
-  metadata.gz: 7f0b4f401895a9b09705d488b96451e8f965d862f24f60255a4db401d2ef0f8b87dc45b960815cd3c64878c28cf63fcbdd43c4124e714e0ef39ccd3876417a51
-  data.tar.gz: ff395e97f4c500d9bd3cada7b0e4ed68af6ae1d8f23eb1bacc16c58217b6cabd197d185b6c3950042e2f254344c7f917bcbe0322a2307a9526d3c916cb77e91e
+  metadata.gz: f40523f9ac4d79e603c568833f82a94945c6086bf96a8b64bd5125594f98b094274230bb0c65d1c01d59c9a16cca4412e9862ccf29c37aeec1a83dfafc816b87
+  data.tar.gz: 80c5ad06795a01788c6c07cb4ec29454bc39d61e6fe369e0e07ff1248b1f23d0d4acd52483f051d3e39d474e93e2f7eb9e897391b33ceaf25f700704cc1ca710

data/.gitignore

@@ -0,0 +1,20 @@
+# Ignore all logfiles and tempfiles
+/log/
+/tmp/
+/tags
+.byebug_history
+
+# Package and dependency caches
+/.bundle
+/Gemfile.lock
+/pkg/
+
+# Generated documentation
+/doc/
+/.yardoc
+/_yardoc/
+
+# Spec reports and failure tracking
+/coverage/
+/spec/rspec-status.txt
+/spec/reports/

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.7
+  - 2.6
+  - 2.5
+  - 2.4

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.15.1] 2020-07-30
+
+### Fixed
+- Fix Ruby 2.7 Proc.new warning ([#10](https://github.com/heroku/l2meter/pull/10))
+
+## [0.15.0] 2020-05-15
+
+### Added
+- Allow outputting of true/false/nil values via a config option. ([#9](https://github.com/heroku/l2meter/pull/9))
+
+## [0.14.0] 2020-04-16
+
+### Added
+- CHANGELOG.md
+
+### Changed
+- Officially only support Ruby 2.5+; all older Rubies are EoL'd.
+
+### Fixed
+- Fix Ruby 2.7 proc warning
+- Fix Ruby 2.7 last argument as keyword params warning
+
+## [0.13.0] 2019-05-11
+
+### Changed
+- Total re-write to fix memory leaks in `L2meter::ThreadSafe` proxy object. See: https://github.com/heroku/l2meter/issues/6

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

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=main)](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 an exception inside the block, all relevant information is logged
+and then the 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,162 +86,189 @@ 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 possible 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 other l2met-specific methods are supported.
+Some [l2met]-specific metrics 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:
+Global context works similarly to context method, but globally:
 
 ```ruby
 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"
 ```
 
 Note that returning nil value will make l2meter omit the field completely.
 
+### "Compacting" values
+
+By default l2meter will treat key-value pairs where the value is `true`, `false` or `nil` differently. `false` and `nil` values will cause the whole pair to be omitted, `true` will cause just the key to be output:
+
+```ruby
+logger.log foo: "hello", bar: true  # => foo=hello bar
+logger.log foo: "hello", bar: false # => foo=hello
+logger.log foo: "hello", bar: nil   # => foo=hello
+```
+
+When the option is disabled, the full pairs are emitted:
+
+```ruby
+config.compact_values = false
+logger.log foo: "hello", bar: true  # => foo=hello bar=true
+logger.log foo: "hello", bar: false # => foo=hello bar=false
+logger.log foo: "hello", bar: nil   # => foo=hello bar=null
+```
+
+Note that "null" is output in the `nil` case.
+
 ## Silence
 
-There's a way to temporary silence the log emitter. This might be userful for
+There's a way to temporary silence the log emitter. This might be useful 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 +276,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/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/l2meter.gemspec

@@ -0,0 +1,35 @@
+require File.expand_path("../lib/l2meter/version", __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name = "l2meter"
+  spec.version = L2meter::VERSION
+  spec.authors = ["Pavel Pravosud"]
+  spec.email = ["pavel@pravosud.com"]
+
+  spec.summary = "L2met friendly log formatter"
+  spec.description = "L2meter is a tool for building logfmt-compatiable loggers."
+  spec.homepage = "https://github.com/heroku/l2meter"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "bug_tracker_uri" => "#{spec.homepage}/issues",
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = []
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.8.0"
+  spec.add_development_dependency "timecop"
+end

data/lib/l2meter.rb

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

data/lib/l2meter/configuration.rb

@@ -1,11 +1,11 @@
 module L2meter
   class Configuration
-    attr_writer :output
+    attr_writer :context, :output
     attr_accessor :source, :prefix, :float_precision, :scrubber
-    attr_reader :context, :key_formatter, :output
+    attr_reader :key_formatter, :output
 
     DEFAULT_KEY_FORMATTER = ->(key) do
-      key.to_s.strip.downcase.gsub(/[^-a-z\d.#]+/, ?-)
+      key.to_s.strip.downcase.gsub(/[^-a-z\d.#]+/, "-")
     end
 
     private_constant :DEFAULT_KEY_FORMATTER
@@ -15,6 +15,8 @@ module L2meter
       @key_formatter = DEFAULT_KEY_FORMATTER
       @output = $stdout
       @float_precision = 4
+      @context = nil
+      @compact_values = true
     end
 
     def format_keys(&block)
@@ -29,14 +31,20 @@ module L2meter
       @sort = !!value
     end
 
-    def context
-      if block_given?
-        @context = Proc.new
+    def compact_values?
+      @compact_values
+    end
+
+    def compact_values=(value)
+      @compact_values = !!value
+    end
+
+    def context(&block)
+      if block
+        @context = block
       else
         @context
       end
     end
-
-    attr_writer :context
   end
 end

data/lib/l2meter/emitter.rb

@@ -4,230 +4,307 @@ module L2meter
   class Emitter
     attr_reader :configuration
 
+    BARE_VALUE_SENTINEL = Object.new.freeze
+
     def initialize(configuration: Configuration.new)
       @configuration = configuration
-      @buffer = {}
-      @autoflush = true
-      @contexts = []
-      @outputs = []
     end
 
-    def log(*args)
-      merge! *current_contexts, *args
+    def log(*args, &block)
+      merge!(current_context, *args)
 
-      if block_given?
-        wrap &proc
+      if block
+        wrap(&block)
       else
         write
       end
     end
 
-    def with_elapsed(start_time = Time.now, &block)
-      context(elapsed_context(start_time), &block)
+    def context(*context_data, &block)
+      if block
+        wrap_context(context_data, &block)
+      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)
+    def silence(&block)
+      with_output(NullOutput.new, &block)
     end
 
     def silence!
-      @outputs.push NullObject.new
+      set_output(NullOutput.new)
     end
 
     def unsilence!
-      @outputs.pop
+      set_output(nil)
+    end
+
+    def with_output(new_output)
+      old_output = output
+      set_output(new_output)
+      yield
+    ensure
+      set_output(old_output)
+    end
+
+    def batch
+      old_state = in_batch?
+      in_batch!
+      yield
+    ensure
+      reset_in_batch(old_state)
+      write
     end
 
-    def measure(metric, value, unit: nil)
-      log_with_prefix :measure, metric, value, unit: unit
+    def measure(metric, value, **args)
+      log_with_prefix(:measure, metric, value, **args)
     end
 
-    def sample(metric, value, unit: nil)
-      log_with_prefix :sample, metric, value, unit: unit
+    def sample(metric, value, **args)
+      log_with_prefix(:sample, metric, value, **args)
     end
 
     def count(metric, value = 1)
-      log_with_prefix :count, metric, value
+      log_with_prefix(:count, metric, value)
     end
 
     def unique(metric, value)
-      log_with_prefix :unique, metric, value
+      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(&block)
+      elapsed = elapse
+      cloned_buffer = buffer.clone
+      write(at: :start)
+      result, exception = capture(&block)
+      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 = false
+    def capture
+      [yield, nil]
+    rescue Object => exception
+      [nil, exception]
+    end
+
+    def wrap_context(context_data)
+      dynamic_contexts.concat(context_data)
       yield
     ensure
-      @autoflush = true
-      fire!
+      context_data.each { dynamic_contexts.pop }
     end
 
-    def merge!(*args)
-      @buffer.merge! format_keys(unwrap(args))
+    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
+      configuration.source ? {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
+    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
-      return if value.nil?
-      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
+      when value == true && configuration.compact_values?
+        key
+      when !value && configuration.compact_values?
+        nil
+      when value == BARE_VALUE_SENTINEL
+        key
+      else
+        value = format_value(value)
+        "#{key}=#{value}"
       end
     end
 
     def format_value(value)
       case value
-      when /[^\w,.:@\-\]\[]/
-        value.strip.gsub(/\s+/, " ").inspect
-      when String
-        value.to_s
       when Float
-        format_float(value)
+        format_float_value(value)
+      when String
+        format_string_value(value)
       when Time
-        value.iso8601
-      when Hash
-        format_value(value.inspect)
+        format_time_value(value)
       when Array
-        value.map(&method(:format_value)).join(?,)
+        value.map(&method(:format_value)).join(",")
+      when nil
+        "null"
       else
         format_value(value.to_s)
       end
     end
 
-    def format_keys(hash)
-      hash.each_with_object({}) do |(key, value), acc|
-        key = configuration.key_formatter.call(key)
-        acc[key] = value
+    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)
+      /[^\w,.:@\-\]\[]/.match?(value) ?
+        value.strip.gsub(/\s+/, " ").inspect :
+        value.to_s
+    end
+
+    def merge!(*args)
+      unwrap(args.compact).each do |key, value|
+        key = format_key(key)
+        buffer[key] = value
       end
     end
 
-    def write(params = nil)
-      merge! params
-      fire! if @autoflush
+    def format_key(key)
+      configuration.key_formatter.call(key)
     end
 
-    def log_with_prefix(method, key, value, unit: nil)
-      key = [configuration.prefix, key, unit].compact * ?.
-      log Hash["#{method}##{key}", value]
-    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)
+      {}.tap do |result|
+        args.each do |arg|
+          next if arg.nil?
+          arg = Hash[arg, BARE_VALUE_SENTINEL] 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 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,6 @@
+module L2meter
+  class NullOutput
+    def print(*)
+    end
+  end
+end

data/lib/l2meter/version.rb

@@ -1,3 +1,3 @@
 module L2meter
-  VERSION = "0.11.0".freeze
+  VERSION = "0.15.1".freeze
 end

metadata

@@ -1,34 +1,114 @@
 --- !ruby/object:Gem::Specification
 name: l2meter
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.15.1
 platform: ruby
 authors:
 - Pavel Pravosud
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2017-04-26 00:00:00.000000000 Z
-dependencies: []
-description: 
+date: 2020-07-30 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: L2meter is a tool for building logfmt-compatiable loggers.
 email:
 - pavel@pravosud.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
 - LICENSE.txt
 - README.md
+- Rakefile
+- l2meter.gemspec
 - 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: {}
+metadata:
+  homepage_uri: https://github.com/heroku/l2meter
+  source_code_uri: https://github.com/heroku/l2meter
+  bug_tracker_uri: https://github.com/heroku/l2meter/issues
+  changelog_uri: https://github.com/heroku/l2meter/blob/main/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -44,8 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.4
 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