gallus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 411a743f66a68e2f25e37c20ff108513e9b4baf6
+  data.tar.gz: ea6360329a24846efa92d86cf3a1250afdb116cd
+SHA512:
+  metadata.gz: 14e6d3d70973ca0fcc6d194782100c16dc926e89458d61d200c0ad577f96082f876c38a5fd213e9f64e164ffe09b2ba717ea96c43b01b12c44f4488de82efeb0
+  data.tar.gz: e81bae8f87270af9a4297c0237b4017463ecc8a580cf4ed8ebadbfa74cc348f7e3337bdf76546163ecfcc2e30dfea7814b68ee11c33b7d4609a12e41658efb43

data/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+...
+
+## [0.1.0]
+
+...
+
+### Added
+
+- Project extracted from other library and moved into this standalone gem.
+- Documentation.

data/Dockerfile

@@ -0,0 +1,11 @@
+FROM ruby:2.2
+
+ENV GEM_NAME gallus
+ENV WORKDIR /usr/local/src/$GEM_NAME
+
+RUN mkdir -p $WORKDIR
+WORKDIR $WORKDIR
+ADD . $WORKDIR
+RUN bundle install
+
+CMD bundle exec rake spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gallus.gemspec
+gemspec

data/README.md

@@ -0,0 +1,227 @@
+# Gallus
+
+[![Codeship Status for jobandtalent/gallus](https://codeship.com/projects/3c59b1b0-9dd1-0133-8d35-5e859e904c15/status?branch=master)](https://codeship.com/projects/127615)
+
+_**Gallus Anonymus**_ (Polonized variant: _**Gall Anonim**_) is the name traditionally given to the anonymous author of Gesta principum Polonorum (Deeds of the Princes of the Poles), composed in Latin about 1115. Gallus is generally regarded as the first historian to have described Poland. His Chronicles are an obligatory text for university courses in Poland's history.
+
+![Gallus Anonymus](http://i.imgur.com/QpQ2g7B.jpg)
+
+Picture stolen from: https://www.flickr.com/photos/maxcuo/15601437990
+
+Gallus is a logger for Ruby apps.
+
+Q: **Why write yet another logger for ruby?**<br />
+A: Because culture of logging among ruby developers is very low and tools used are either
+prehistoric (Log4r) or messed up and insufficient (Standard library logger, logging library, etc.)
+
+Q: **What's so special about Gallus?**<br />
+A: Nothing really, it's just a collection of best practices from loggers of different technologies (like Log4j & Slf4j, Python logging, etc.)
+
+Q: **So why would I use Gallus over Log4r for example.**<br />
+A: Because it's simpler to customize, it's more powerful by default, it's more robust in working with context variables.
+
+Q: **Is it faster than Log4r or standard logger?**<br />
+A: It is not. It's about 30-60% slower depending on the log level (check `hacking/benchmarks.rb` for comparison with Log4r).
+
+Q: **What? It's slower even than Log4r, why would I event want to use it?**<br />
+A: Log4r provides much more limited way to work with contexts, and this is where the overhead comes from. If you'd wrap Log4r with adapter that works the same way as Gallus, performance would be the same. On a side note, if you consider performance of logging as your bottleneck then you evidently do something wrong.
+
+Q: **Yeah? So logger can be slow?**<br />
+A: Gallus ain't no slow, it's slower than Log4r, a tradeoff of convenience in usage. It's still blazingly fast comparing with all your business logic operations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gallus', '0.1.0'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gallus --version 0.1.0
+
+## Usage
+
+Start off from configuring root logger:
+
+```ruby
+require 'gallus'
+
+Gallus::Log.configure do |log|
+  log.level = :INFO
+  log.output << Gallus::Output::Stderr.new(Gallus::Format::SimpleLog.new)
+end
+```
+
+Simple logging:
+
+```ruby
+Gallus::Log.root.info("Hello, this is info message")
+# => I @ 2016-01-15T16:32:56+01:00Z $ root > Hello, this is info message
+
+Gallus::Log.root.info("With context", foo: 1, bar: "baz")
+# => I @ 2016-01-15T16:32:56+01:00Z $ root > With context; foo=1 bar="baz"
+
+Gallus::Log.root.info("With lazy context", foo: 1, bar: -> { 100 * 2 })
+# => I @ 2016-01-15T16:32:56+01:00Z $ root > With context; foo=1 bar=200
+```
+
+Nothing fancy so far. Lets try injecting loggers into classes:
+
+```ruby
+class User < Struct.new(:name)
+  include Gallus::Logging
+
+  def greet
+    log.info("Greeted", name: name)
+    "Hello, I'm #{name}"
+  end
+end
+
+User.new("Jon Snow").greet
+# => I @ 2016-01-15T16:32:56+01:00Z $ User > Greeted; name="Jon Snow"
+```
+
+Wow, did you see that? What did just happened? We have logger injected and configured with one `include`.
+And those neat context variables:
+
+```ruby
+log.info("Multi level contexts", foo: 1, bar: 2)
+# => I @ 2016-01-15T16:32:56+01:00Z $ root > Multi level context; foo=1 bar=2
+```
+
+What about global contexts?
+
+```ruby
+Gallus::Log.global_context { |ctx| ctx[:location] = "Castle Black" }
+
+SamwellTarly.log.info("I always wanted to be a Wizard", name: "Samwell Tarly")
+# => I always wanted to be a Wizard; name="Samwell Tarly" location="Castle Black"
+
+JonSnow.log.info("I know nothing", name: "Jon Snow")
+# => I know nothing; name="Jon Snow" location="Castle Black"
+```
+
+Q: Why block in `global_context` call?<br/>
+A: Because it's thread-safe this way.
+
+Speaking of threads...
+
+```ruby
+t1 = Thread.new do
+  Gallus::Log.current_thread_context { |ctx| ctx[:location] = "Castle Black" }
+  SamwellTarly.log.info("I always wanted to be a Wizard", name: "Samwell Tarly")
+end
+
+t2 = Thread.new do
+  Gallus::Log.current_thread_context { |ctx| ctx[:location] = "Beyond the Wall" }
+  JonSnow.log.info("I know nothing", name: "Jon Snow")
+end
+
+t1.join
+t2.join
+
+# => I always wanted to be a Wizard; name="Samwell Tarly" location="Castle Black"
+# => I know nothing; name="Jon Snow" location="Beyond the Wall"
+```
+
+Yeap, you can have context variables per thread too.
+
+### Hacking
+
+Finally, you can customize pretty much everything here. Output, serialization and formatting handlers are
+all callables (Proc interfaces). So you can do something like this:
+
+```ruby
+
+Gallus::Log.configure do |log|
+  custom_format = -> (event) { "#{event.level} (#{event.payload[:pid]}): #{event.message}" }
+  log.output << Gallus::Output::Stderr.new(custom_format)
+end
+```
+
+Or even like this:
+
+```ruby
+Gallus::Log.configure do |log|
+  log.output << -> (event) { puts event.inspect }
+end
+```
+
+### Configuration inheritance
+
+Given logger `Foo` and `Foo::Bar`, and `Foo::Bar::Baz` - `Foo` inherits from `root`, `Foo::Bar` from `Foo`, etc...
+You can override configuration manually:
+
+```ruby
+Gallus::Log.configure do |log|
+  log.level = :INFO
+end
+
+Gallus::Log.configure("Foo") do |log|
+  log.level = :ERROR
+end
+
+Gallus::Log.configure("Foo::Bar") do |log|
+  log.level = :DEBUG
+end
+```
+
+**NOTE**: Configuration must be executed before creation of the logger. At this point configuration is frozen and
+child loggers can't be reconfigured. You can reconfigure particular logger though.
+
+## Development
+
+You have two options to work with this project. The [docker flow](#setup-with-docker) is suggested since solves problems of compatibility of tools.
+
+### Manual Setup
+
+First off, make sure you have **Ruby 2.2+** and latest version of **Bundler** on your machine. After checking out the repo, you can install dependencies and prepare the project with:
+
+    $ bin/setup
+
+Now you can run tests:
+
+    $ bundle exec rake spec
+
+You can also connect to interactive prompt that will allow you to experiment. To do this, run:
+
+    $ bundle exec bin/console
+
+To install this gem onto your local machine, run:
+
+    $ bundle exec rake install
+
+To run all example files, use following rake task:
+
+    $ bundle exec rake examples
+
+### Setup with Docker
+
+If you're lazy and don't wanna get into how the setup works, here's something for you. This project comes fully [dockerized](http://docker.io/). Install docker toolchain and then go for:
+
+    $ docker-compose build
+
+All done, you can do testing and fiddling around:
+
+    $ docker-compose run gallus bash
+    root@xyyyyxx:/usr/local/src/gallus# bundle exec rake spec
+    root@xyyyyxx:/usr/local/src/gallus# bundle exec bin/console
+
+### Releasing new version
+
+This project is powered by rake-bump. To release gem version, follow [this continuous releasing guide](https://github.com/jobandtalent/rake-bump#continuous-releasing).
+
+**NOTE**: This gem is a dependency for `rake-bump`, so to avoid circular dependency issues you should invoke bump tasks follow:
+
+    $ bundle exec rake -r rake/bump/tasks bump
+    $ bundle exec rake -r rake/bump/tasks release:rubygems
+
+## Contributing
+
+Bug reports and pull requests are welcome [here](https://github.com/jobandtalent/gallus/issues).

data/Rakefile

@@ -0,0 +1,27 @@
+require "rake/testtask"
+
+if defined?(Rake::Bump)
+  require File.expand_path("../lib/gallus/version", __FILE__)
+
+  Rake::Bump::Tasks.new do |t|
+    t.gem_name = 'gallus'
+    t.gem_current_version = Gallus::VERSION
+  end
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc "Run all examples in sequence"
+task :examples do
+  Pathname.new(Dir.pwd).join('examples').each_child do |f|
+    puts "-----> Executing example: #{f.basename}"
+    system("ruby #{f.to_s}") if f.file?
+    puts
+  end
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gallus"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docker-compose.yml

@@ -0,0 +1,4 @@
+gallus:
+  build: .
+  volumes:
+    - .:/usr/local/src/gallus:rw

data/examples/current_thread_context.rb

@@ -0,0 +1,28 @@
+require 'gallus'
+
+include Gallus
+
+Log.configure do |log|
+  log.output << Output::Stderr.new(Format::SimpleLog.new)
+end
+
+class SamwellTarly
+  include Logging
+end
+
+class JonSnow
+  include Logging
+end
+
+t1 = Thread.new do
+  Log.current_thread_context { |ctx| ctx[:location] = "Castle Black" }
+  SamwellTarly.log.info("I always wanted to be a Wizard", name: "Samwell Tarly")
+end
+
+t2 = Thread.new do
+  Log.current_thread_context { |ctx| ctx[:location] = "Beyond the Wall" }
+  JonSnow.log.info("I know nothing", name: "Jon Snow")
+end
+
+t1.join
+t2.join

data/examples/custom_format.rb

@@ -0,0 +1,10 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  custom_format = -> (event) { "#{event.level} (#{event.payload[:pid]}): #{event.message}" }
+  log.output << Output::Stderr.new(custom_format)
+end
+
+logger.info('Custom format here...', pid: Process.pid)

data/examples/custom_output.rb

@@ -0,0 +1,9 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  log.output << -> (event) { puts event.inspect }
+end
+
+logger.info('Context as JSON again, but custom serialization used this time', foo: 1, bar: 'baz')

data/examples/custom_serialization.rb

@@ -0,0 +1,10 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  custom_json_serialization = -> (event) { event.to_json }
+  log.output << Output::Stderr.new(Format::SimpleLog.new(custom_json_serialization))
+end
+
+logger.info('Context as JSON again, but custom serialization used this time', foo: 1, bar: 'baz')

data/examples/global_context.rb

@@ -0,0 +1,19 @@
+require 'gallus'
+
+include Gallus
+
+Log.configure do |log|
+  log.output << Output::Stderr.new(Format::SimpleLog.new)
+end
+
+class SamwellTarly
+  include Logging
+end
+
+class JonSnow
+  include Logging
+end
+
+Log.global_context { |ctx| ctx[:location] = "Castle Black" }
+SamwellTarly.log.info("I always wanted to be a Wizard", name: "Samwell Tarly")
+JonSnow.log.info("I know nothing", name: "Jon Snow")

data/examples/json_serialization.rb

@@ -0,0 +1,9 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  log.output << Output::Stderr.new(Format::SimpleLog.new(Serialization::JSON))
+end
+
+logger.info('Context as JSON', foo: 1, bar: 'baz')

data/examples/lambda_context_vars.rb

@@ -0,0 +1,9 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  log.output << Output::Stderr.new(Format::SimpleLog.new)
+end
+
+logger.info('Testing lambdas', foo: -> { 10 * 20 })

data/examples/simple_console.rb

@@ -0,0 +1,13 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  log.level = :DEBUG
+  log.output << Output::Stderr.new(Format::SimpleConsole.new)
+end
+
+logger.info('This is console output')
+logger.warn('Everything else than INFO is being prefixed')
+logger.debug('Checking debugs, just in case')
+logger.error('And errors too...')

data/examples/simple_log.rb

@@ -0,0 +1,12 @@
+require 'gallus'
+
+include Gallus
+
+logger = Log.configure('test') do |log|
+  log.level = :DEBUG
+  log.output << Output::Stderr.new(Format::SimpleLog.new)
+end
+
+logger.info('Hello World')
+logger.warn('Not everything is what it seems', planet: 'Earth')
+logger.info('Another info message with context', foo: 1, bar: 2)

data/gallus.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gallus/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "gallus"
+  spec.version = Gallus::VERSION
+  spec.authors = ["jobandtalent", "Kris Kovalik"]
+  spec.email = ["kris.kovalik@jobandtalent.com", "hi@kkvlk.me"]
+
+  spec.summary = %q{Production grade logger for Ruby.}
+  spec.description = %q{Easy to use and insanely powerfull logger for Ruby applications.}
+  spec.homepage = "https://github.com/jobandtalent/gallus"
+  spec.license = 'Apache-2.0'
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
+  spec.add_development_dependency "mocha", "~> 1.1"
+  spec.add_development_dependency "log4r", "~> 1.1", ">= 1.0"
+  #spec.add_development_dependency "rake-bump", "~> 0.4", ">= 0.4.6"
+
+  spec.add_dependency "activesupport", "~> 4.2", ">= 3.0"
+end

data/hacking/benchmarks.rb

@@ -0,0 +1,47 @@
+# Usage: LEVEL=INFO N=10000 bundle exec ruby hacking/benchmarks.rb
+
+require 'log4r'
+require 'gallus'
+require 'stringio'
+require 'benchmark'
+
+LEVEL = ENV.fetch('LEVEL', 'INFO')
+
+$gallus = Gallus::Log.configure('test') do |log|
+  log.level = LEVEL
+  log.output << Gallus::Output::Stream.new(StringIO.new, Gallus::Format::SimpleLog.new)
+end
+
+N = ENV.fetch('N', 10000).to_i
+calls = []
+
+N.times do
+  %w[debug info warn error].each do |level|
+    calls << level
+  end
+end
+
+Log4r::IOOutputter.new('stream', StringIO.new, formatter: Log4r::PatternFormatter.new(pattern: "%l @ %d $ %C - %m"))
+
+$log4r = Log4r::Logger.new('test')
+$log4r.level = Log4r.const_get(LEVEL)
+$log4r.add('stream')
+
+payload = { one: 1, two: "Two", three: Object.new, four: "Yada! yada! yada!" }
+
+Benchmark.bm do |x|
+  x.report("Log4r: ") do
+    calls.dup.shuffle.each do |level|
+      $log4r.send(level) do
+        formatted_payload = payload.map { |k,v| "#{k}=#{v.inspect}" }.join(" ")
+        "This is fancy little message; #{formatted_payload}"
+      end
+    end
+  end
+
+  x.report("Gallus: ") do
+    calls.dup.shuffle.each do |level|
+      $gallus.send(level, "This is fancy little message", payload)
+    end
+  end
+end

data/lib/gallus/event.rb

@@ -0,0 +1,15 @@
+module Gallus
+  # Internal: Every log event is wrapped with this envelope. It holds information about the logger that
+  # performed the operation, log level, message (or object passed) and full payload. Also includes information
+  # at what time event has been recorded.
+  Event = Struct.new(:logger, :level, :message, :payload) do
+    attr_reader :recorded_at
+
+    def initialize(*)
+      super
+
+      self.payload = Payload.new(payload || {})
+      @recorded_at = Time.now.utc
+    end
+  end
+end

data/lib/gallus/format/simple_console.rb

@@ -0,0 +1,25 @@
+module Gallus
+  module Format
+    # Public: This console log format is used for command line apps. Instead of using puts-es and write-s to
+    # display stuff use logger! INFO level will be displayed without prefixes, as is - just message and context
+    # info. Other levels will be prefixed with level name. Example:
+    #
+    #   Hello, this is info message
+    #   ERROR: Upps, something went wrong; foo="Bar"
+    #   Another info message
+    #   DEBUG: Here's debug information
+    #   ...
+    #
+    class SimpleConsole
+      def initialize(serialization = Serialization::Inspect)
+        @serialization = serialization
+      end
+
+      def call(event)
+        parts = [ [ event.message, @serialization.call(event.payload) ].compact.join('; ') ]
+        parts.unshift(format("%s:", event.level.name)) unless event.level == Level::INFO
+        parts.compact.join(' ')
+      end
+    end
+  end
+end

data/lib/gallus/format/simple_log.rb

@@ -0,0 +1,18 @@
+module Gallus
+  module Format
+    # Public: Simple because of implementation, not because of the output. It's default log line that contains
+    # most information needed. Everything presented in a compact and easy to parse form. Example:
+    #
+    #   "I @ 2016-01-15T16:32:56+01:00Z $ Foo > Hello World; foo=1 bar=2"
+    class SimpleLog
+      def initialize(serialization = Serialization::Inspect)
+        @serialization = serialization
+      end
+
+      def call(event)
+        message = [ event.message, @serialization.call(event.payload) ].compact.join('; ')
+        format("%s @ %s $ %s > %s", event.level.name[0], event.recorded_at.iso8601, event.logger, message)
+      end
+    end
+  end
+end

data/lib/gallus/level.rb

@@ -0,0 +1,50 @@
+module Gallus
+  # Internal: Log level represented in a coherent way. You can easily compare log levels between each other.
+  # You're also able to get log level by string/symbol name.
+  class Level
+    include Comparable
+
+    # Internal: All log levels.
+    def self.all
+      @all ||= []
+    end
+
+    # Internal: Shorthand to all.each.
+    def self.each(&block)
+      self.all.each(&block)
+    end
+
+    # Internal: Returns level defined under given name.
+    def self.[](name)
+      const_get(name.to_s)
+    end
+
+    attr_reader :name, :id
+
+    # Internal: Constructor. Initializes logger with given name and identifier, then registers it.
+    def initialize(name, id)
+      @name, @id = name.to_s, id
+
+      self.class.const_set(@name, self)
+      self.class.all << self
+    end
+
+    def <=>(other)
+      self.id <=> other.id
+    rescue => err
+      return nil
+    end
+
+    def to_s
+      name
+    end
+
+    # Register available log levels:
+
+    new :TRACE, 1
+    new :DEBUG, 2
+    new :INFO,  3
+    new :WARN,  4
+    new :ERROR, 5
+  end
+end

data/lib/gallus/log.rb

@@ -0,0 +1,162 @@
+module Gallus
+  # Public: The brain of logging. All defined loggers inherit from this class.
+  class Log
+    # Global context requires a semaphore to be thread-safe.
+    @@global_context_mutex = Mutex.new
+
+    # Global context stores context variables that will be printed by any logger alongside with its
+    # local information.
+    @@global_context = {}
+
+    class << self
+      # Public: Configures logger with given name. When no name specified, root logger will be configured.
+      #
+      # Example:
+      #
+      #   Gallus::Log.configure do |log|
+      #     log.level = :INFO
+      #     log.output << -> (event) { puts event.inspect }
+      #   end
+      #
+      # Returns configured logger.
+      def configure(name = '', &block)
+        Repository.get_or_create_logger(name, &block)
+      end
+
+      # Public: Returns logger registered under given name.
+      def [](name)
+        configure(name)
+      end
+
+      # Internal: For testing purposes we should be able to remove logger with given name.
+      def delete(name)
+        Repository.delete_with_children(name)
+      end
+
+      # Internal: Performance magic. It dynamically defines log level methods to avoid overhead of not-logged
+      # levels. For example if log level is WARN it'll define empty `trace`, `debug` and `info` methods and fully
+      # working `warn` and `error`. Effectively log methods call `log` under the hood.
+      def define_log_methods!(log_level)
+        Level.each do |level|
+          method_name = level.name.downcase
+          remove_method(method_name) if method_defined?(method_name)
+
+          if level >= log_level
+            define_method(method_name) do |message = nil, payload = {}, &block|
+              log(level, message, payload, &block)
+            end
+          else
+            define_method(method_name) do |message = nil, payload = {}, &block|
+              # supressed...
+            end
+          end
+        end
+      end
+
+      # Public: Yields global context. Only block calls are allowed since this operation must be thread-safe.
+      #
+      # Example:
+      #
+      #   log.global_context { |ctx| ctx[:location] = "Castle Black" }
+      #   samwell_log.info("I always wanted to be a Wizard", name: "Samwell Tarly")
+      #   # => I always wanted to be a Wizard; name="Samwell Tarly" location="Castle Black"
+      #   jon_snow_log.info("I know nothing", name: "Jon Snow")
+      #   # => I know nothing; name="Jon Snow" location="Castle Black"
+      #
+      def global_context
+        @@global_context_mutex.synchronize { yield @@global_context }
+      end
+
+      # Public: Yields context for current thread. Just to conform with the behavior of #global_context we're
+      # using block call here as well.
+      #
+      # Example:
+      #
+      #   log.current_thread_context { |ctx| ctx[:location] = "Castle Black" }
+      #   log.info("I know nothing!", name: "Jon Snow")
+      #   # => I know nothing! name="Jon Snow" location="Castle Black"
+      #
+      def current_thread_context
+        yield (Thread.current[:log_context] ||= {})
+      end
+
+      # Public: Returns root logger.
+      def root
+        @@root
+      end
+    end
+
+    # Public: Logger name, log level and context serializtion handler.
+    attr_accessor :name, :level
+
+    # Public: A list with configured outputs.
+    attr_reader :output
+
+    # Internal: Parent logger. Used for testing purposes.
+    attr_reader :parent
+
+    # Internal: Constructs new logger with configuration inherited from given parent. Yields itself so
+    # it can be reconfigured with a block. Don't use this method directly. Use Gallus::Log.configure class
+    # method if you wanna define or reconfigure a logger.
+    def initialize(parent, name, &block)
+      @parent, @name = parent, name.to_s
+
+      if parent
+        @output = @parent.output.dup
+        self.level = @parent.level
+      end
+
+      @output ||= []
+
+      yield self if block_given?
+    end
+
+    # Public: Changing log level means that we have to redefine logging methods.
+    def level=(level)
+      level = level.is_a?(Level) ? level : Level[level.to_s]
+      return if @level == level
+      self.class.class_eval { define_log_methods!(level) }
+      @level = level
+    end
+
+    # Public: Shortand to Gallus::Log.global_context.
+    def global_context(&block)
+      self.class.global_context(&block)
+    end
+
+    # Public: Shortand to Gallus::Log.current_thread_context.
+    def current_thread_context(&block)
+      self.class.current_thread_context(&block)
+    end
+
+    private
+
+    # Internal: Merges data from all contexts and provides them as a single hash. Order:
+    #
+    # 1. Global context.
+    # 2. Curreant thread context.
+    # 3. Self context.
+    #
+    def merged_context
+      {}.tap do |merged|
+        self.class.global_context { |ctx| merged.merge!(ctx) }
+        self.class.current_thread_context { |ctx| merged.merge!(ctx) }
+      end
+    end
+
+    # Internal: Actual logging. Takes payload and merges it into contexts, serializes context variables
+    # using configured serialization handler and finally sends it to each defined output.
+    def log(level, message = nil, payload = {}, &block)
+      message ||= block.call if block_given?
+      event = Event.new(@name, level, message.to_s, merged_context.merge(payload))
+      output.each { |out| out.call(event) }
+    end
+
+    # Root logger configuration (defaults for any logger defined after):
+
+    @@root = Log.configure do |log|
+      log.name = 'root'
+      log.level = Level::INFO
+    end
+  end
+end

data/lib/gallus/logging.rb

@@ -0,0 +1,35 @@
+module Gallus
+  # Internal: Programmers are lazy, why to initialize logger manually in language like Ruby, when you can
+  # use handy one-liner include to have logger available for your class. Example:
+  #
+  #   class Foo
+  #     include Gallus::Logging
+  #
+  #     def initialize
+  #       log.debug("Initializing!")
+  #     end
+  #   end
+  #
+  #   Gallus::Log.configure('Foo') do |log|
+  #     log.level = :DEBUG
+  #     log.output << Gallus::Output::Stdout.new(Gallus::Format::SimpleConsole.new)
+  #   end
+  #
+  #   Foo.new # => "DEBUG: Initializing!"
+  #
+  module Logging
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    def log
+      self.class.log
+    end
+
+    module ClassMethods
+      def log
+        @log ||= ::Gallus::Log.configure(self.name)
+      end
+    end
+  end
+end

data/lib/gallus/output/file.rb

@@ -0,0 +1,15 @@
+module Gallus
+  module Output
+    # Public: A thread safe IO stream output that writes to given file.
+    class File < Stream
+      def initialize(filename, format)
+        @file = ::File.open(filename, 'a+')
+        super(@file, format)
+      end
+
+      def close
+        @file.close
+      end
+    end
+  end
+end

data/lib/gallus/output/null.rb

@@ -0,0 +1,9 @@
+module Gallus
+  module Output
+    # Public: Prints nothing.
+    class Null
+      def call
+      end
+    end
+  end
+end

data/lib/gallus/output/stderr.rb

@@ -0,0 +1,10 @@
+module Gallus
+  module Output
+    # Public: A thread safe IO stream output that writes to standard error.
+    class Stderr < Stream
+      def initialize(format)
+        super($stderr, format)
+      end
+    end
+  end
+end

data/lib/gallus/output/stdout.rb

@@ -0,0 +1,10 @@
+module Gallus
+  module Output
+    # Public: A thread safe IO stream output that writes to standard output.
+    class Stdout < Stream
+      def initialize(format)
+        super($stdout, format)
+      end
+    end
+  end
+end

data/lib/gallus/output/stream.rb

@@ -0,0 +1,19 @@
+module Gallus
+  module Output
+    # Public: Simple, thread-safe IO stream output handler. Takes stream and format on input.
+    class Stream
+      def initialize(stream, format)
+        @mutex = Mutex.new
+        @stream, @format = stream, format
+      end
+
+      def call(event)
+        @mutex.synchronize { call!(event) }
+      end
+
+      def call!(event)
+        @stream.write(@format.call(event) + "\n")
+      end
+    end
+  end
+end

data/lib/gallus/package_logging.rb

@@ -0,0 +1,19 @@
+module Gallus
+  # Public: Similarly to Gallus::Logging no point to initialize global logger for your
+  # modules/packages. Include this mixin to define LOG constant and log class method shortcut.
+  #
+  # Often used practice is to define such top level logger as a parent with default outputters,
+  # formatters, log level, etc.
+  module PackageLogging
+    def self.included(klass)
+      klass.const_set(:LOG, ::Gallus::Log.configure(klass.name))
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def log
+        const_get(:LOG)
+      end
+    end
+  end
+end

data/lib/gallus/payload.rb

@@ -0,0 +1,26 @@
+module Gallus
+  # Internal: To improve performance, context can provide values wrapped in lambdas. Those will be
+  # executed at the time of writing log. Getting the values from lambdas is the job of this simple
+  # payload class.
+  class Payload
+    include Enumerable
+    extend  Forwardable
+
+    def_delegators :@h, :empty?, :each
+
+    def initialize(payload)
+      @h = payload.inject({}) do |res,(k,v)|
+        res[k.to_sym] = v.is_a?(Proc) ? v.call : v
+        res
+      end
+    end
+
+    def to_h
+      @h
+    end
+
+    def inspect
+      @h.map { |k,v| "#{k}=#{v.inspect}" }.join(" ")
+    end
+  end
+end

data/lib/gallus/repository.rb

@@ -0,0 +1,53 @@
+module Gallus
+  # Internal: Wee need a place to keep track of registered loggers and their parents. This little
+  # repository class handles this task in a thread-safe manner.
+  class Repository
+    PARENT_DELIMITER = '::'
+
+    @mutex = Mutex.new
+
+    # Internal: Returns all registered loggers.
+    def self.all
+      @all ||= {}
+    end
+
+    # Internal: There must be a way to find parent logger for given class name. For example, looking up parent
+    # for Foo::Bar::Baz logger it'll look up for Foo::Bar, then falling back to Foo and eventually to root logger
+    # if nothing found.
+    def self.find_parent(name)
+      parent, name = nil, name.dup
+
+      while parent.nil?
+        name = name.split(PARENT_DELIMITER)[0..-2].join(PARENT_DELIMITER)
+        parent = all[name]
+        break if name.empty?
+      end
+
+      parent
+    end
+
+    # Internal: For testing purposes we need to be able to delete logger alongside with all its children.
+    def self.delete_with_children(name)
+      @mutex.synchronize do
+        all.keys.each { |k| all.delete(k) if k.start_with?(name + PARENT_DELIMITER) }
+        all.delete(name)
+      end
+    end
+
+    # Internal: We obviously need a way to create logger or retrieve it by name if already registered.
+    # Creation of logger causes configuration to be inherited from parent (or root) logger.
+    def self.get_or_create_logger(name, &block)
+      name, log = name.to_s, nil
+
+      @mutex.synchronize do
+        if log = all[name]
+          yield log if block_given?
+        else
+          all[name] = (log = Class.new(Log).new(find_parent(name), name, &block))
+        end
+      end
+
+      log
+    end
+  end
+end

data/lib/gallus/serialization/inspect.rb

@@ -0,0 +1,11 @@
+module Gallus
+  module Serialization
+    # Public: Serialization handler that produces inspected key=value data.
+    class Inspect
+      def self.call(payload)
+        return if payload.nil? or payload.empty?
+        payload.inspect
+      end
+    end
+  end
+end

data/lib/gallus/serialization/json.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+module Gallus
+  module Serialization
+    # Public: Serialization handler that produces JSON data.
+    class JSON
+      def self.call(payload)
+        return if payload.nil? or payload.empty?
+        payload.to_h.to_json
+      end
+    end
+  end
+end

data/lib/gallus/version.rb

@@ -0,0 +1,3 @@
+module Gallus
+  VERSION = '0.1.0'
+end

data/lib/gallus.rb

@@ -0,0 +1,22 @@
+require 'time'
+require 'thread'
+
+module Gallus
+  require 'gallus/version'
+  require 'gallus/format/simple_console'
+  require 'gallus/format/simple_log'
+  require 'gallus/output/null'
+  require 'gallus/output/stream'
+  require 'gallus/output/stdout'
+  require 'gallus/output/stderr'
+  require 'gallus/output/file'
+  require 'gallus/serialization/inspect'
+  require 'gallus/serialization/json'
+  require 'gallus/level'
+  require 'gallus/payload'
+  require 'gallus/event'
+  require 'gallus/repository'
+  require 'gallus/log'
+  require 'gallus/logging'
+  require 'gallus/package_logging'
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: gallus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jobandtalent
+- Kris Kovalik
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Easy to use and insanely powerfull logger for Ruby applications.
+email:
+- kris.kovalik@jobandtalent.com
+- hi@kkvlk.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- CHANGELOG.md
+- Dockerfile
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docker-compose.yml
+- examples/current_thread_context.rb
+- examples/custom_format.rb
+- examples/custom_output.rb
+- examples/custom_serialization.rb
+- examples/global_context.rb
+- examples/json_serialization.rb
+- examples/lambda_context_vars.rb
+- examples/simple_console.rb
+- examples/simple_log.rb
+- gallus.gemspec
+- hacking/benchmarks.rb
+- lib/gallus.rb
+- lib/gallus/event.rb
+- lib/gallus/format/simple_console.rb
+- lib/gallus/format/simple_log.rb
+- lib/gallus/level.rb
+- lib/gallus/log.rb
+- lib/gallus/logging.rb
+- lib/gallus/output/file.rb
+- lib/gallus/output/null.rb
+- lib/gallus/output/stderr.rb
+- lib/gallus/output/stdout.rb
+- lib/gallus/output/stream.rb
+- lib/gallus/package_logging.rb
+- lib/gallus/payload.rb
+- lib/gallus/repository.rb
+- lib/gallus/serialization/inspect.rb
+- lib/gallus/serialization/json.rb
+- lib/gallus/version.rb
+homepage: https://github.com/jobandtalent/gallus
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Production grade logger for Ruby.
+test_files: []