hedgelog 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODBjYWJhZDM5N2Q0Mzg0Y2QwZWVlZGMwMDg1ZTc1YWY0ZjgxZGJlNg==
+  data.tar.gz: !binary |-
+    NTZmZTYyNzRmYTNkNTExZDEyMDBlYzcxMzljZmEyNjY4MWRmMjdiYQ==
+SHA512:
+  metadata.gz: !binary |-
+    M2Y0NzU1YjVmMzU4NmEzMGRmMmY0MzgzOGVmOTEyYTcwM2MxNGEzNDdlMThi
+    M2IwOTI2MjdmYmFlMTlhODgxNjNiYjE2MzQzMzRkMzNmZjRkYjM3NmUzNDBi
+    OGJkZDgxNWRiODY4NmMwOTUyYjk5YmJmZmIwMjczMjRhOTRmYmI=
+  data.tar.gz: !binary |-
+    NjM0MTUxZmQxYzMxY2Y2ZjNmM2I5NGY2NjI0ZTQ1ZDM3NjQ4MTQ3ODQ1OGRl
+    ZTFhZDlkOGQyNDQ1YzkwZWIzNTc1ZWQwYjlhNDAxNjliOTQ1NDYxYWRiNGQ0
+    NDgwZDJjNTU1NGVlYzUyN2YwYTU5MmJmODdiNTA0NTMxZTkzMTE=

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+coverage
+.*DS_Store
+*.gem

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,53 @@
+# This is the configuration used to check the rubocop source code.
+inherit_from: #{RUBOCOP_HOME}/config/default.yml
+
+AllCops:
+  Include:
+    - '**/lib/**/*'
+  Exclude:
+    - 'bin/**/*'
+
+CyclomaticComplexity: 
+  Max: 15
+
+PerceivedComplexity:
+  Max: 20
+
+MethodLength:
+  Max: 30
+
+ClassLength:
+  Enabled: false
+
+LineLength:
+  Max: 150
+
+WordArray:
+  Enabled: false
+
+LeadingCommentSpace:
+  Enabled: false
+
+CommentAnnotation:
+  Enabled: false
+
+Documentation:
+  Enabled: false
+
+Next:
+  Enabled: false
+
+OptionalArguments:
+  Enabled: false
+
+SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+SignalException:
+  EnforcedStyle: only_raise
+
+TrivialAccessors:
+  AllowPredicates: true
+
+BlockNesting:
+  Max: 4

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_filter '/spec/'
+end

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 1.9.3
+script:
+  - bundle exec rspec
+  - bundle exec rubocop

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Contributing
+
+Pull requests are always appreciated.
+
+To get started contributing, fork and clone the repo:
+
+```
+git clone git@github.com:your-username/hedgelog.git
+```
+
+Install development Gems:
+
+```
+bundle install
+```
+
+Make your code changes.
+
+Make sure that your changes do not break any existing tests:
+
+```
+rspec
+```
+
+Pull requests **will not be accepted** for any additional functionality without adding accompanying tests. Moreover, the repository contains a configuration for [Rubocop](https://github.com/bbatsov/rubocop). Pull requests will also not be accepted that do not pass the rubocop style-check. To check this simply run:
+
+```
+rubocop
+```

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hedgelog.gemspec
+gemspec
+
+group :test, :development do
+  gem "rake", "~> 10.0"
+  gem "rspec", "~> 3.3"
+  gem "pry"
+  gem "simplecov", "~> 0.10"
+  gem "rubocop", "~> 0.33"
+  gem "timecop"
+end
+
+group :development do
+  gem 'ruby-prof'
+  gem 'guard-rspec', require: false
+end

data/Guardfile

@@ -0,0 +1,70 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec --format progress" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Firespring
+
+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,84 @@
+# Hedgelog
+
+This gem provides an opinionated Ruby logger for writing structured JSON logs. It attempts to maintain compatibility with the standard Ruby logger api while extending it with functionality relevant to JSON logging.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hedgelog'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hedgelog
+
+## Basic Usage
+
+```ruby
+require 'hedgelog'
+
+# Logging defaults to STDOUT or you can pass a file path to .new
+logger = Hedgelog::Channel.new
+
+logger.level = :info
+
+logger.debug "Foo"
+# No Output
+
+logger.info "Foo"
+=> {"message":"FOO","timestamp":"2015-07-15T12:03:08.257356","level_name":"info","level":1}
+
+logger.info "FOO", sample: 'data'
+=> {"context": {"sample":"data"},"message":"FOO","timestamp":"2015-07-15T12:05:02.302202","level_name":"info","level":1}
+
+# It also supports logging as a block with extra data
+logger.info { ["FOO", {sample: 'data'}] }
+=> {"context", {"sample":"data"},"message":"FOO","timestamp":"2015-07-15T12:06:20.026807","level_name":"info","level":1}
+```
+
+## Context
+
+Hedgelog allows adding additional context to an instance of a logger that will get output with each log message
+
+```ruby
+logger[:request_id] = 1234
+=> 1234
+logger.info "FOO"
+=> {"request_id":1234,"message":"FOO","timestamp":"2015-07-15T12:09:33.129984","level_name":"info","level":1}
+```
+
+## Sub-channels
+
+One of the primary features of Hedgelog is the usage of sub-channels.
+
+Sub-channels can have their own context separate from the main loggers context. This allows including additional information for all log messages from a portion of your application.
+
+```ruby
+subchannel = logger.subchannel(:database)
+subchannel.info "FOO"
+=> {"subchannel":"database","message":"FOO","timestamp":"2015-07-15T12:12:39.147210","level_name":"info","level":1}
+
+# The subchannel does not effect the primary instance of the logger
+logger.info "FOO"
+=>{"message":"FOO","timestamp":"2015-07-15T12:13:31.132059","level_name":"info","level":1}
+```
+
+The sub-channel instances conform to the same interface as Hedgelog. Therefore they can be passed in as standard Ruby loggers to gems that take an instance of Ruby logger for input.
+
+```ruby
+DataMapper.logger = logger.subchannel(:database)
+```
+
+## Scrubbing
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/firespring/hedgelog.
+
+For details on the pull request process please see our [contributing documentation](CONTRIBUTING.md)

data/Rakefile

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

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hedgelog"
+
+# 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.
+
+require "pry"
+Pry.start

data/bin/profile

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hedgelog"
+require 'ruby-prof'
+require 'logger'
+
+logger = Hedgelog.new('/dev/null')
+logger.level = Logger::INFO
+
+RubyProf.start
+10000.times do
+  logger.info 'Foo'
+end
+result = RubyProf.stop
+result.eliminate_methods!([/Integer#times/])
+
+
+# printer = RubyProf::GraphPrinter.new(result)
+printer = RubyProf::FlatPrinterWithLineNumbers.new(result)
+printer.print(STDOUT)

data/bin/setup

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

data/config/pre_commit.yml

@@ -0,0 +1,9 @@
+---
+:checks_add:
+- :rubocop
+- :ruby
+- :pry
+- :merge_conflict
+- :rspec_focus
+:checks_remove:
+- :rails

data/hedgelog.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hedgelog/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hedgelog"
+  spec.version       = Hedgelog::VERSION
+  spec.licenses      = ['MIT']
+  spec.authors       = ["Jeff Utter"]
+  spec.email         = ["jeff.utter@firespring.com"]
+  spec.homepage      = 'https://github.com/firespring/hedgelog'
+
+  spec.summary       = "An opinionated/strucutred JSON logger for Ruby" 
+  spec.description   = "An opinionated/structured JSON logger for Ruby"
+  spec.homepage      = "http://firespring.com"
+
+  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_dependency "yajl-ruby", "~> 1.2"
+  spec.add_development_dependency "bundler", "~> 1.7"
+end

data/lib/hedgelog/context.rb

@@ -0,0 +1,64 @@
+require 'hedgelog/scrubber'
+
+class Hedgelog
+  class Context
+    def initialize(scrubber, data = {})
+      raise ::ArgumentError, "#{self.class}: argument must be Hash got #{data.class}." unless data.is_a? Hash
+      check_reserved_keys(data)
+      @data = data
+      @scrubber = scrubber
+    end
+
+    def []=(key, val)
+      raise ::ArgumentError, "#{self.class}: The #{key} is a reserved key and cannot be used." if Hedgelog::RESERVED_KEYS.include? key.to_sym
+
+      @data[key] = val
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def delete(key)
+      @data.delete(key)
+    end
+
+    def clear
+      @data = {}
+    end
+
+    def merge(hash)
+      @data.merge(hash)
+    end
+
+    def merge!(hash_or_context)
+      check_reserved_keys(hash_or_context) unless hash_or_context.is_a? Hedgelog::Context
+
+      hash_or_context = hash_or_context.to_h if hash_or_context.respond_to?(:to_h)
+      @data = hash_or_context.merge(@data)
+    end
+
+    def overwrite!(hash_or_context)
+      check_reserved_keys(hash_or_context) unless hash_or_context.is_a? Hedgelog::Context
+
+      hash_or_context = hash_or_context.to_h if hash_or_context.respond_to?(:to_h)
+      @data.merge!(hash_or_context)
+    end
+
+    def scrub!
+      @data = @scrubber.scrub(@data)
+      self
+    end
+
+    def to_h
+      @data
+    end
+
+    private
+
+    def check_reserved_keys(hash)
+      invalid_keys = Hedgelog::RESERVED_KEYS & hash.keys
+      raise ::ArgumentError, "#{self.class}: The following keys are reserved and cannot be used #{invalid_keys.to_a}." if invalid_keys.length > 0
+    end
+  end
+end

data/lib/hedgelog/scrub_replacement.rb

@@ -0,0 +1,39 @@
+class Hedgelog
+  class ScrubReplacement
+    def initialize(key, replacement)
+      @key = key
+      @replacement = replacement
+      @match_regex = /("?)#{@key}("?[=:]\s*"?)(.+?)(["&,;\s]|$)/
+    end
+
+    def scrub_string(string)
+      string.gsub!(@match_regex) do
+        start = Regexp.last_match[1]
+        eql = Regexp.last_match[2]
+        delim = Regexp.last_match[4]
+        "#{start}#{@key}#{eql}#{@replacement}#{delim}"
+      end
+    end
+
+    def scrub_hash(hash)
+      hash.each do |key, val|
+        next hash[key] = @replacement if key.to_s.downcase == @key.to_s.downcase
+        scrub_thing(val)
+      end
+    end
+
+    def scrub_array(array)
+      array.each do |val|
+        scrub_thing(val)
+      end
+    end
+
+    private
+
+    def scrub_thing(thing)
+      scrub_string(thing) if thing.is_a?(String)
+      scrub_array(thing) if thing.is_a?(Array)
+      scrub_hash(thing) if thing.is_a?(Hash)
+    end
+  end
+end

data/lib/hedgelog/scrubber.rb

@@ -0,0 +1,20 @@
+require 'hedgelog/scrub_replacement'
+
+class Hedgelog
+  class Scrubber
+    def initialize(replacements = nil)
+      @replacements = replacements || [
+        ScrubReplacement.new('pasword', '**********')
+      ]
+    end
+
+    def scrub(data)
+      # Need to Marshal.dump/Marshal.load to deep copy the input so that scrubbing doesn't change global state
+      d = Marshal.load(Marshal.dump(data))
+      @replacements.each do |r|
+        r.scrub_hash(d)
+      end
+      d
+    end
+  end
+end

data/lib/hedgelog/version.rb

@@ -0,0 +1,3 @@
+class Hedgelog
+  VERSION = '0.1.0'
+end

data/lib/hedgelog.rb

@@ -0,0 +1,167 @@
+require 'hedgelog/version'
+require 'hedgelog/context'
+require 'hedgelog/scrubber'
+require 'logger'
+require 'yajl'
+
+class Hedgelog
+  LEVELS = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN).each_with_object({}).with_index do |(v, h), i|
+    h[v] = i
+    h[v.downcase] = i
+    h[v.to_sym] = i
+    h[v.downcase.to_sym] = i
+    h[i] = v.downcase.to_sym
+  end.freeze
+
+  TOP_LEVEL_KEYS = [:app, :channel, :level, :level_name, :message, :request_id, :timestamp]
+  RESERVED_KEYS = [:app, :level, :level_name, :timestamp, :context, :caller]
+
+  TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S.%6N'.freeze
+  BACKTRACE_RE = /([^:]+):([0-9]+)(?::in `(.*)')?/
+
+  def initialize(logdev = STDOUT, shift_age = nil, shift_size = nil)
+    @channel_context = Hedgelog::Context.new(@scrubber)
+    @level = LEVELS[:debug]
+    @channel = nil
+    @logdev = nil
+    @app = nil
+    @scrubber = Hedgelog::Scrubber.new
+
+    if logdev.is_a?(self.class)
+      @channel = logdev
+    else
+      @logdev = Logger::LogDevice.new(logdev, shift_age: shift_age, shift_size: shift_size)
+    end
+  end
+
+  attr_reader :level
+
+  def level=(level)
+    int_level = level_to_int(level)
+    raise ::ArgumentError, "#{self.class}#level= , #{level} is not a valid level." if int_level.nil?
+    @level = int_level
+  end
+
+  attr_writer :app
+
+  def add(severity = LEVELS[:unknown], message = nil, progname = nil, context, &block)
+    return true if (@logdev.nil? && @channel.nil?) || severity < @level
+
+    message, context = *block.call if block
+    context ||= {}
+
+    context = Hedgelog::Context.new(@scrubber, context) unless context.is_a? Hedgelog::Context
+    context.merge!(@channel_context)
+    context[:message] ||= message
+
+    return write(severity, context) if @logdev
+
+    @channel.add(severity, nil, progname, context) if @channel
+  end
+
+  def []=(key, val)
+    @channel_context[key] = val
+  end
+
+  def [](key)
+    @channel_context[key]
+  end
+
+  def delete(key)
+    @channel_context.delete(key)
+  end
+
+  def clear_channel_context
+    @channel_context = {}
+  end
+
+  def channel(name)
+    sc = self.class.new(self)
+    sc.level = @level
+    channel_name = name
+    channel_name = "#{self[:channel]} => #{name}" if self[:channel]
+    sc[:channel] = channel_name
+    sc
+  end
+
+  %w(fatal error warn info debug unknown).each do |level|
+    predicate = "#{level}?".to_sym
+    level = level.to_sym
+
+    define_method(level) do |message = nil, context = {}, &block|
+      raise ::ArgumentError, "#{self.class}##{level} requires at least 1 argument or a block" if !message && !block
+      raise ::ArgumentError, "#{self.class}##{level} requires either a message OR a block" if message && block
+      raise ::ArgumentError, "#{self.class}##{level} context is a #{context.class}, it must be a Hash" unless context.is_a?(Hash)
+
+      return true unless send(predicate)
+
+      add(level_to_int(level), message, nil, context, &block)
+    end
+
+    define_method(predicate) do
+      level_to_int(level) >= @level
+    end
+  end
+
+  private
+
+  def level_to_int(level)
+    return level if level.is_a?(Fixnum)
+    LEVELS[level]
+  end
+
+  def level_from_int(level)
+    return LEVELS[level] if level.is_a?(Fixnum)
+    level.to_sym
+  end
+
+  def write(severity, context)
+    return true if @logdev.nil?
+
+    context.scrub!
+
+    data = context.merge(default_data(severity))
+    data[:app] = @app if @app
+    data[:caller] = debugharder(caller[3]) if debug?
+    data = extract_top_level_keys(data)
+
+    @logdev.write(Yajl::Encoder.encode(data) + "\n")
+  end
+
+  def default_data(severity)
+    {
+      timestamp: Time.now.strftime(TIMESTAMP_FORMAT),
+      level_name: level_from_int(severity),
+      level: severity
+    }
+  end
+
+  def extract_top_level_keys(context)
+    data = {}
+    TOP_LEVEL_KEYS.each do |key|
+      data[key] = context.delete(key) if context.key? key
+    end
+    data[:context] = context
+    data
+  end
+
+  def debugharder(callinfo)
+    m = BACKTRACE_RE.match(callinfo)
+    return unless m
+    path, line, method = m[1..3]
+    whence = $LOAD_PATH.find { |p| path.start_with?(p) }
+    if whence
+      # Remove the RUBYLIB path portion of the full file name
+      file = path[whence.length + 1..-1]
+    else
+      # We get here if the path is not in $:
+      file = path
+    end
+
+    {
+      file: file,
+      line: line,
+      method: method
+    }
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: hedgelog
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeff Utter
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: An opinionated/structured JSON logger for Ruby
+email:
+- jeff.utter@firespring.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rubocop.yml
+- .simplecov
+- .travis.yml
+- CONTRIBUTING.md
+- Gemfile
+- Guardfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/console
+- bin/profile
+- bin/setup
+- config/pre_commit.yml
+- hedgelog.gemspec
+- lib/hedgelog.rb
+- lib/hedgelog/context.rb
+- lib/hedgelog/scrub_replacement.rb
+- lib/hedgelog/scrubber.rb
+- lib/hedgelog/version.rb
+homepage: http://firespring.com
+licenses:
+- MIT
+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.4.3
+signing_key: 
+specification_version: 4
+summary: An opinionated/strucutred JSON logger for Ruby
+test_files: []