black_box_log_formatter 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 275820a316bedaf428836876bfcb9be824e1ef31
+  data.tar.gz: 9adf51ced61d0ad3427e604f5547a2294da41f88
+SHA512:
+  metadata.gz: 6cd2cba3fbd305bee6e99057c426c0a1a9addbe839a703096e3e50d1e45a148e95cce21acc91a5d5a7af48f21b7bfa984fcbb7ff7ac905b1a9b59b17640a5f4d
+  data.tar.gz: 1e7fb47903ed23881e664fd8775491dd8576692b67c2a0ef23ef03922ad638e9d5a41ee5a4d981ed1e558a62ff7d6c8b5612dd6a4eb6b4bcc69f4cd9ff93c769

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+black_box_log_formatter

data/.ruby-version

@@ -0,0 +1 @@
+2.1.10

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,123 @@
+# BlackBox::LogFormatter
+
+This is an incredibly colorful highlighting formatter for structured log
+events.  It is visually similar to Ruby's `Logger::Formatter`, but can display
+additional color-highlighted metadata on the same line or on subsequent lines,
+using ANSI color escape sequences.
+
+Not everyone likes this much color and detail, so you (TODO) can configure which
+log event fields to display inline, which to display in a multi-line format, and
+which to hide altogether.  You can also disable color.
+
+This gem was extracted from an internal middleware framework at Deseret Book
+called BlackBox Framework.  It's named for the fact that good middleware should
+allow frontend services to treat backend services like a black box, not caring
+about implementation details.
+
+
+## Features
+
+- Each application name, process, thread, worker, and job gets its own color,
+  so you can visually identify log messages from the same process, thread, or
+  worker in a combined log stream.  You need to manually add these metadata
+  fields to your log events if your logger doesn't do it for you.
+
+  ```ruby
+  threads = []
+  10.times do |i|
+    threads << Thread.new do
+      l.info message: "On thread #{i}", tid: Thread.current.__id__
+      sleep rand
+      l.info message: "Back on #{i}", tid: Thread.current.__id__
+    end
+  end ; threads.each(&:join)
+  ```
+
+  ![Colorized thread IDs](screenshots/colorized_threads.png?raw=true)
+
+
+- Log events are colored according to severity:
+  - DEBUG - dark gray
+  - INFO - default
+  - WARN - yellow
+  - ERROR - red
+  - FATAL - magenta
+  - UNKNOWN - cyan
+
+  ```ruby
+  [:debug, :info, :warn, :error, :fatal, :unknown].each do |level|
+    l.send(level, { message: "Message at #{level}", a: 1, b: 2, colors: true })
+  end
+  ```
+
+  ![Colorized log levels](screenshots/colorized_levels.png?raw=true)
+
+- Backtraces are colorized to make it easy to identify files, line numbers, and
+  method names:
+
+  ```ruby
+  l.warn trace: caller
+  ```
+
+  ![Highlighted backtrace](screenshots/colorized_backtraces.png?raw=true)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'black_box_log_formatter'
+```
+
+## Usage
+
+Set `BlackBox::LogFormatter` as the formatter for a logger, then pass it
+`Hash`es instead of `String`s.  Event `Hash`es should be simliar to those used
+by Logstash.  Do not pass untrusted data in the `message` field or as
+unfiltered fields in the event.
+
+Pass primary metadata fields using symbols as keys, not strings.
+
+```ruby
+require 'black_box_log_formatter'
+
+l = Logger.new($stdout)
+l.progname = 'A Program'
+l.formatter = BlackBox::LogFormatter.new
+
+l.debug "The old way to log"
+# => D, [2016-05-06T16:21:44.520640 #32413] DEBUG -- A Program: hostname The old way to log
+
+l.debug(
+  message: "The new way to log",
+  tid: 'some thread',
+  wid: 'some worker',
+  data: { useful: :fields }
+)
+# => D, [2016-05-06T16:22:32.027060 #32413/T-some thread/W-some worker] DEBUG -- A Program: hostname The new way to log: {
+#    :data => {
+#      :useful => :fields
+#      }
+#    }
+```
+
+![Simple logging example](screenshots/readme_example_1.png?raw=true)
+
+
+TODO: describe configuring the color and formatting options
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/deseretbook/black\_box\_log\_formatter.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT) (see the LICENSE file).
+
+©2016 Deseret Book and contributors.  Developed by Mike Bourgeous at
+DeseretBook.com, with metadata work by Dustin Grange.  See Git for any
+additional contributors.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+Dir[File.expand_path('../lib/tasks/**/*.rake', __FILE__)].each do |f|
+  load f
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "black_box_log_formatter"
+
+# 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 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/black_box_log_formatter.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'black_box_log_formatter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "black_box_log_formatter"
+  spec.version       = BlackBoxLogFormatter::VERSION
+  spec.authors       = ["Mike Bourgeous", "Dustin Grange", "Deseret Book"]
+  spec.email         = ["webdev@deseretbook.com"]
+
+  spec.summary       = %q{A colorful formatter and highlighter for structued log events}
+  spec.description   = <<-DESC
+    This is an incredibly colorful highlighting formatter for structured log
+    events.  It is visually similar to Ruby's `Logger::Formatter`, but can display
+    additional color-highlighted metadata on the same line or on subsequent lines.
+  DESC
+  spec.homepage      = "https://github.com/deseretbook/black_box_log_formatter"
+  spec.license       = "MIT"
+
+  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.required_ruby_version = '>= 2.1.0'
+
+  spec.add_runtime_dependency 'awesome_print', '~> 1.6.1'
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/black_box/awesome_backtrace.rb

@@ -0,0 +1,68 @@
+# Extension for AwesomePrint that highlights Arrays of backtrace strings.  Not
+# compatible with AwesomePrint's HTML output.
+# (C)2016 Deseret Book, created April 2016 by Mike Bourgeous/DeseretBook.com
+
+require 'awesome_print'
+
+module BlackBox
+  module AwesomeBacktrace
+    # Regular expression identifying and modifying a backtrace line
+    TRACE_REGEX = %r{(/?)([^:/]+):(\d+):in `([^']*)'}
+
+    def self.included(base)
+      base.send :alias_method, :cast_without_awesome_backtrace, :cast
+      base.send :alias_method, :cast, :cast_with_awesome_backtrace
+    end
+
+    # Check for a backtrace-decorated array from BlackBox::Log.
+    def cast_with_awesome_backtrace(object, type)
+      if type == :array
+        if defined?(::Thread::Backtrace::Location) && object.all?{|e| e.is_a?(::Thread::Backtrace::Location) }
+          cast = :caller_location_backtrace
+        elsif object.all?{|t| t.is_a?(String) && (t == '...' || t =~ TRACE_REGEX) }
+          # FIXME: this highlights [ '...' ] as well
+          cast = :string_backtrace
+        end
+      end
+
+      cast || cast_without_awesome_backtrace(object, type)
+    end
+
+    # TODO: Consider using #awesome_array and formatting each string
+    # separately to get the indentation and numbering for free
+
+    # TODO: Consider searching for common backtrace filters, such as Rails,
+    # for excluding unwanted backtrace entries.
+
+    # Format a Thread::Backtrace::Location array from #caller_locations.
+    def awesome_caller_location_backtrace(object)
+      awesome_string_backtrace(object.map(&:to_s), '=> ', nil) # TODO: maybe use the objects directly?
+    end
+
+    # Format a String array from #caller or Exception#backtrace.
+    def awesome_string_backtrace(object, open_quote='"', close_quote='"')
+      open_quote = colorize(open_quote, :string) if open_quote
+      close_quote = colorize(close_quote, :string) if close_quote
+
+      s = "[\n"
+      s << object.map{|s|
+        s = AwesomeBacktrace.format_line(s) unless @options[:plain] || !@inspector.colorize?
+        "#{indent}#{open_quote}#{s}#{close_quote},\n"
+      }.join
+      s << "#{outdent}]"
+
+      s
+    end
+
+    # Adds ANSI highlights to and escapes control characters in the given
+    # backtrace line.
+    def self.format_line(line)
+      "\e[0;36m" + line.inspect[1..-2].sub(
+        TRACE_REGEX,
+        "\\1\e[1;33m\\2\e[0m:\e[34m\\3\e[0m:in `\e[1;35m\\4\e[0m'"
+      ).rstrip
+    end
+  end
+end
+
+AwesomePrint::Formatter.send(:include, BlackBox::AwesomeBacktrace)

data/lib/black_box/log_formatter.rb

@@ -0,0 +1,207 @@
+# Colorized, structured variant of Ruby's built-in Logger::Formatter.
+# (C)2016 Deseret Book, created September 2014 by Mike Bourgeous/DeseretBook.com
+
+require 'logger'
+require 'digest/md5'
+require 'socket'
+
+module BlackBox
+  # Colorized, structured variant of Ruby's built-in Logger::Formatter.
+  class LogFormatter < ::Logger::Formatter
+    # Whether to highlight log lines in color.
+    attr_accessor :color
+
+    # Initializes a color formatter for the given +logger+ (optional).  By
+    # default, color will be disabled if the Logger is logging to a file
+    # (uses #instance_variable_get(:@filename)), enabled based on ENV['TERM']
+    # otherwise.
+    #
+    # If +color+ is true or false (instead of nil), then color will be
+    # enabled or disabled regardless of the attached logger's target or the
+    # TERM environment variable.
+    def initialize(logger: nil, color: nil)
+      @pidcol = nil
+      @appcol = nil
+      @appname = nil # App name at last time of app name color calculation
+      @color = color == true || (
+        color != false &&
+        (!logger || !logger.instance_variable_get(:@filename)) &&
+        !!(ENV['TERM'].to_s.downcase =~ /(linux|mac|xterm|ansi|putty|screen)/)
+      )
+
+      AwesomePrint.force_colors! if Kernel.const_defined?(:AwesomePrint) && @color
+    end
+
+    def call(severity, datetime, progname, msg)
+      # FIXME: Add inline metadata (TID, WID, JID) even if color is disabled
+      return super(severity, datetime, progname, self.class.format(msg, true, false)) unless @color
+
+      sc = severity_color(severity)
+      dc = date_color(severity)
+      pc = process_color(severity)
+      mc = message_color(severity)
+      ac = appname_color(severity, progname)
+      ec = env_color(progname)
+      rc = "\e[0;1;30m"
+
+      pid = "#{pc}##{$$}"
+      host = Socket.gethostname
+      env = nil
+      tags = nil
+
+      if msg.is_a?(Hash)
+        t = msg[:tid]
+        w = msg[:wid]
+        j = msg[:jid] || msg['jid']
+
+        pid << "#{rc}/#{digest_color_bold(t)}T-#{t}" if t
+        pid << "#{rc}/#{digest_color_bold(w)}W-#{w}" if w
+        pid << "#{rc}/#{digest_color_bold(j)}J-#{j}" if j
+
+        tags = msg[:tags] if msg[:tags].is_a?(Array)
+        host = msg[:host] if msg[:host].is_a?(String)
+        env = msg[:env] if msg[:env]
+      end
+
+      hc = "\e[1m#{digest_color(host)}"
+
+      "#{sc}#{severity[0..0]}#{rc}, [#{dc}#{format_datetime(datetime)}#{pc}#{pid}#{rc}] #{sc}#{severity[0..4]}" +
+        "#{rc} -- #{ac}#{progname}#{env && " #{ec}(#{env})"}#{rc}: #{hc}#{host}#{rc} #{self.class.format_tags(tags)}" +
+        "#{mc}#{msg2str(self.class.format(msg, false, true), mc)}\e[0m\n"
+    end
+
+    # Formats the given +event+ into a String, using AwesomePrint or
+    # JSON.pretty_generate if possible, or using #inspect if not.  Removes
+    # common metadata elements from Hash data, and if +add_metadata+ is
+    # true, adds some of them back to the message string.
+    #
+    # This could definitely be cleaner.
+    def self.format(event, add_metadata, ap_color)
+      return event.to_s unless event.is_a?(Hash)
+
+      event = event.clone
+
+      msg = event.delete(:message)
+      host = event.delete(:host)
+      pname = event.delete(:process_name)
+      env = event.delete(:env)
+      pid = event.delete(:pid) # Process ID
+      tid = event.delete(:tid) # Thread ID
+      wid = event.delete(:wid) # Worker ID
+      jid = event.delete(:jid) || event.delete('jid') # Job ID
+      tags = event.delete(:tags) if event[:tags].is_a?(Array)
+
+      event.delete(:request_id) if event[:request_id] == jid
+
+      if add_metadata
+        msg = "#{format_tags(tags)}#{msg}"
+      end
+
+      if event.any?
+        begin
+          if Kernel.const_defined?(:AwesomePrint) && event.respond_to?(:ai)
+            data = event.ai(indent: -2, plain: !ap_color, multiline: true)
+          else
+            data = JSON.pretty_generate(event)
+          end
+        rescue => e
+          data = event.inspect rescue "INSPECTION FAILED"
+        end
+
+        msg = "#{msg}: #{data}"
+      end
+
+      msg
+    end
+
+    # Formats an array of +tags+ as a string like "[tag1] [tag2]...", with
+    # a trailing space if there are any tags.
+    def self.format_tags(tags)
+      "#{tags.map{|t| "[#{t}]"}.join(' ')} " if tags && tags.any?
+    end
+
+    protected
+    # FIXME: These would be more efficient as constant arrays
+    def severity_color(severity)
+      case severity
+      when 'DEBUG'
+        "\e[1;30m"
+      when 'INFO'
+        "\e[1;34m"
+      when 'WARN'
+        "\e[1;33m"
+      when 'ERROR'
+        "\e[1;31m"
+      when 'FATAL'
+        "\e[1;35m"
+      else
+        "\e[1;36m"
+      end
+    end
+
+    def message_color(severity)
+      case severity
+      when 'DEBUG'
+        "\e[1;30m"
+      when 'INFO'
+        "\e[0m"
+      when 'WARN'
+        "\e[0;33m"
+      when 'ERROR'
+        "\e[0;31m"
+      when 'FATAL'
+        "\e[0;35m"
+      else
+        "\e[0;36m"
+      end
+    end
+
+    def date_color(severity)
+      "\e[0;36m"
+    end
+
+    def process_color(severity)
+      return @pidcol if @pidcol
+      @pidcol = "\e[0m#{digest_color($$)}"
+    end
+
+    def appname_color(severity, progname)
+      return @appcol if @appcol && @appname == progname
+      @appname = progname
+      @appcol = "\e[1m#{digest_color(@appname)}"
+    end
+
+    def env_color(progname)
+      return @envcol if @envcol && @appname == progname
+      @appname = progname
+      @envcol = "\e[0m#{digest_color(@appname)}"
+    end
+
+    # Returns a color escape based on the digest of the given +value+.
+    def digest_color(value)
+      "\e[#{31 + digest(value) % 6}m"
+    end
+
+    # Returns a reset, bold, and color escape based on the +value+.
+    def digest_color_bold(value)
+      color = digest(value) % 15 + 1
+      if color > 7
+        "\e[0;1;#{30 + color - 8}m"
+      else
+        "\e[0;#{30 + color}m"
+      end
+    end
+
+    # Returns an integer based on the MD5 digest of the given +value+.
+    def digest(value)
+      digest = Digest::MD5.digest(value.to_s).unpack('I*')
+      digest[0] ^ digest[1] ^ digest[2] ^ digest[3]
+    end
+
+    private
+    # Overrides superclass to preserve the color for the message level.
+    def msg2str(msg, color=nil)
+      super(msg).gsub("\e[0m", "\e[0m#{color}")
+    end
+  end
+end

data/lib/black_box_log_formatter.rb

@@ -0,0 +1,7 @@
+require 'black_box_log_formatter/version'
+
+module BlackBoxLogFormatter
+end
+
+require 'black_box/awesome_backtrace'
+require 'black_box/log_formatter'

data/lib/black_box_log_formatter/version.rb

@@ -0,0 +1,3 @@
+module BlackBoxLogFormatter
+  VERSION = "1.0.2"
+end

data/lib/tasks/benchmark.rake

@@ -0,0 +1,39 @@
+desc 'Crude benchmark of the log formatter'
+task :benchmark do
+  require 'black_box_log_formatter'
+  require 'benchmark'
+
+  benchmarks = {
+    'plain string' => 'This is a message to format',
+    'simple hash' => { message: 'This is a message to format' },
+    'hash with data' => { message: 'This is a message to format', meta: 'data', a: 1, b: 2 },
+    'hash with only data' => { meta: 'data', a: 1, b: 2 },
+    'hash with backtrace' => { message: 'Something bad happened', error: caller(0, 5) },
+    'hash with non-trace array' => { message: 'This is a message to format', list: (1..5).to_a },
+  }
+
+  iterations = 100000
+
+  color = BlackBox::LogFormatter.new(color: true)
+  bw = BlackBox::LogFormatter.new(color: false)
+
+  date = Time.now.utc
+
+  benchmarks.each do |name, message|
+    puts "\n\e[1mTesting color with #{name}\e[0m"
+    time = Benchmark.realtime do
+      iterations.times do
+        color.call('FATAL', date, 'a program', message)
+      end
+    end
+    puts "\t#{iterations}/#{time}s = #{'%.2f' % (iterations.to_f / time)}/s"
+
+    puts "\n\e[1mTesting non-color with #{name}\e[0m"
+    time = Benchmark.realtime do
+      iterations.times do
+        bw.call('FATAL', date, 'a program', message)
+      end
+    end
+    puts "\t#{iterations}/#{time}s = #{'%.2f' % (iterations.to_f / time)}/s"
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: black_box_log_formatter
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Mike Bourgeous
+- Dustin Grange
+- Deseret Book
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2
+      This is an incredibly colorful highlighting formatter for structured log
+      events.  It is visually similar to Ruby's `Logger::Formatter`, but can display
+      additional color-highlighted metadata on the same line or on subsequent lines.
+email:
+- webdev@deseretbook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- black_box_log_formatter.gemspec
+- lib/black_box/awesome_backtrace.rb
+- lib/black_box/log_formatter.rb
+- lib/black_box_log_formatter.rb
+- lib/black_box_log_formatter/version.rb
+- lib/tasks/benchmark.rake
+- screenshots/colorized_backtraces.png
+- screenshots/colorized_levels.png
+- screenshots/colorized_threads.png
+- screenshots/readme_example_1.png
+homepage: https://github.com/deseretbook/black_box_log_formatter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A colorful formatter and highlighter for structued log events
+test_files: []