loggerator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b09044e8590344b2433a544b15a853d63e92d06b
+  data.tar.gz: 1fc9edb37658480a85d314177440e4dd79d568c8
+SHA512:
+  metadata.gz: baf7c00883dcfec5e32f33feeabb28d9ecf541a0cfe3c72f503b62740d18d38f2465c71dd676da26d7056c33acad54eac304e5274a61f731037787d8f59237e2
+  data.tar.gz: f5912098321f92a9d449e3029a53cc3c33609531e5c0ea5faf02ee6f8793bb75a5fc742689056fe6ec6c247371e82d7149b26b304185de5fca2662d96079d401

data/lib/generators/loggerator/log_generator.rb

@@ -0,0 +1,17 @@
+module Loggerator
+  class LogGenerator < Rails::Generators::Base
+
+    desc "Creates an initializer for Loggerator logs at config/initializer/log.rb"
+    class_option :a, banner: "APP_NAME", desc: "Specify APP_NAME instead of the one defined by Rails"
+    source_root File.expand_path("../../templates", __FILE__)
+
+    def create_config_file
+      template "log.rb.erb", "config/initializers/log.rb"
+    end
+
+    private
+      def app_name
+        options[:a] || Rails.root.basename
+      end
+  end
+end

data/lib/generators/templates/log.rb.erb

@@ -0,0 +1,4 @@
+Loggerator.default_context = { app: "<%= app_name %>" }
+<% if defined?(Loggerator::Metrics) -%>
+Loggerator::Metrics.name   = "<%= app_name %>"
+<% end -%>

data/lib/loggerator.rb

@@ -0,0 +1 @@
+require 'loggerator/loggerator'

data/lib/loggerator/loggerator.rb

@@ -0,0 +1,146 @@
+require_relative 'request_store'
+require_relative 'middleware'
+
+module Loggerator
+  extend self
+
+  def self.included(mod)
+    mod.extend self
+  end
+
+  def log(data, &block)
+    log_to_stream(stdout, merge_log_contexts(data), &block)
+  end
+
+  def log_error(e, data = {})
+    exception_id = e.object_id
+
+    # Log backtrace in reverse order for easier digestion.
+    if e.backtrace
+      e.backtrace.reverse.each do |backtrace|
+        log_to_stream(stderr, merge_log_contexts(
+          exception_id: exception_id,
+          backtrace:    backtrace
+        ))
+      end
+    end
+
+    # then log the exception message last so that it's as close to the end of
+    # a log trace as possible
+    data.merge!(
+      exception:    true,
+      class:        e.class.name,
+      message:      e.message,
+      exception_id: exception_id
+    )
+
+    data[:status] = e.status if e.respond_to?(:status)
+
+    log_to_stream(stderr, merge_log_contexts(data))
+  end
+
+  def log_context(data, &block)
+    old = local_context
+    self.local_context = old.merge(data)
+    res = block.call
+  ensure
+    self.local_context = old
+    res
+  end
+
+  def default_context=(default_context)
+    @@default_context = default_context
+  end
+
+  def default_context
+    @@default_context ||= {}
+  end
+
+  def stdout=(stream)
+    @@stdout = stream
+  end
+
+  def stdout
+    @@stdout ||= $stdout
+  end
+
+  def stderr=(stream)
+    @@stderr = stream
+  end
+
+  def stderr
+    @@stderr ||= $stderr
+  end
+
+  private
+    def merge_log_contexts(data)
+      default_context.merge(request_context.merge(local_context.merge(data)))
+    end
+
+    def local_context
+      RequestStore.store[:local_context] ||= {}
+    end
+
+    def local_context=(h)
+      RequestStore.store[:local_context] = h
+    end
+
+    def request_context
+      RequestStore.store[:request_context] || {}
+    end
+
+    def log_to_stream(stream, data, &block)
+      unless block
+        str = unparse(data)
+        stream.print(str + "\n")
+      else
+        data = data.dup
+        start = Time.now
+        log_to_stream(stream, data.merge(at: 'start'))
+        begin
+          res = yield
+
+          log_to_stream(stream, data.merge(
+            at: 'finish', elapsed: (Time.now - start).to_f))
+          res
+        rescue
+          log_to_stream(stream, data.merge(
+            at: 'exception', elapsed: (Time.now - start).to_f))
+          raise $!
+        end
+      end
+    end
+
+    def unparse(attrs)
+      attrs.map { |k, v| unparse_pair(k, v) }.compact.join(" ")
+    end
+
+    def unparse_pair(k, v)
+      v = v.call if v.is_a?(Proc)
+      # only quote strings if they include whitespace
+      if v == nil
+        nil
+      elsif v == true
+        k
+      elsif v.is_a?(Float)
+        "#{k}=#{format("%.3f", v)}"
+      elsif v.is_a?(String) && v =~ /\s/
+        quote_string(k, v)
+      elsif v.is_a?(Time)
+        "#{k}=#{v.iso8601}"
+      else
+        "#{k}=#{v}"
+      end
+    end
+
+    def quote_string(k, v)
+      # try to find a quote style that fits
+      if !v.include?('"')
+        %{#{k}="#{v}"}
+      elsif !v.include?("'")
+        %{#{k}='#{v}'}
+      else
+        %{#{k}="#{v.gsub(/"/, '\\"')}"}
+      end
+    end
+end

data/lib/loggerator/metrics.rb

@@ -0,0 +1,41 @@
+require_relative 'loggerator'
+
+module Loggerator
+  module Metrics
+    include Loggerator
+    extend self
+
+    @@metrics_name = 'loggerator'
+
+    def name=(name)
+      @@metrics_name = name
+    end
+
+    def name
+      @@metrics_name
+    end
+
+    def count(key, value=1)
+      log("count##{name}.#{key}" => value)
+    end
+
+    def sample(key, value)
+      log("sample##{name}.#{key}" => value)
+    end
+
+    def unique(key, value)
+      log("unique##{name}.#{key}" => value)
+    end
+
+    def measure(key, value, units='s')
+      log("measure##{name}.#{key}" => "#{value}#{units}")
+    end
+
+  end
+
+  # included Metrics shortcut
+  def m; Metrics; end
+end
+
+# simple alias if its not already being used
+Metrics = Loggerator::Metrics unless defined?(Metrics)

data/lib/loggerator/middleware.rb

@@ -0,0 +1,7 @@
+require_relative 'middleware/request_store'
+require_relative 'middleware/request_id'
+
+module Loggerator
+  module Middleware; end
+end
+

data/lib/loggerator/middleware/request_id.rb

@@ -0,0 +1,55 @@
+module Loggerator::Middleware
+  class RequestID
+    # note that this pattern supports either a full UUID, or a "squashed" UUID
+    # like the kind Hermes sends:
+    #
+    #     full:     01234567-89ab-cdef-0123-456789abcdef
+    #     squashed: 0123456789abcdef0123456789abcdef
+    #
+    UUID_PATTERN =
+      /\A[a-f0-9]{8}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[a-f0-9]{12}\Z/
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request_ids = [SecureRandom.uuid] + extract_request_ids(env)
+
+      # make ID of the request accessible to consumers down the stack
+      env["REQUEST_ID"] = request_ids[0]
+
+      # Extract request IDs from incoming headers as well. Can be used for
+      # identifying a request across a number of components in SOA.
+      env["REQUEST_IDS"] = request_ids
+
+      status, headers, response = @app.call(env)
+
+      # tag all responses with a request ID
+      headers["Request-Id"] = request_ids[0]
+
+      [status, headers, response]
+    end
+
+    private
+      def extract_request_ids(env)
+        request_ids = raw_request_ids(env)
+        request_ids.map! { |id| id.strip }
+        request_ids.select! { |id| id =~ UUID_PATTERN }
+        request_ids
+      end
+
+      def raw_request_ids(env)
+        # We had a little disagreement around the inception of the Request-Id
+        # field as to whether it should be prefixed with `X-` or not. API went
+        # with no prefix, but Hermes went with one. Support both formats on
+        # input.
+        %w(HTTP_REQUEST_ID HTTP_X_REQUEST_ID).inject([]) do |request_ids, key|
+          if ids = env[key]
+            request_ids += ids.split(",")
+          end
+          request_ids
+        end
+      end
+  end
+end

data/lib/loggerator/middleware/request_store.rb

@@ -0,0 +1,14 @@
+module Loggerator::Middleware
+  class RequestStore
+    def initialize(app, options={})
+      @app = app
+      @store = options[:store] || Loggerator::RequestStore
+    end
+
+    def call(env)
+      @store.clear!
+      @store.seed(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/loggerator/namespace.rb

@@ -0,0 +1,22 @@
+require_relative 'loggerator'
+
+module Loggerator
+  module Namespace
+    include Loggerator
+
+    def log(data={}, &blk)
+      log_namespace!
+      super
+    end
+
+    def log_error(e, data={})
+      log_namespace!
+      super
+    end
+
+    private
+      def log_namespace!
+        self.local_context = { ns: self.class.name }
+      end
+  end
+end

data/lib/loggerator/rails.rb

@@ -0,0 +1,22 @@
+require_relative "loggerator"
+
+module Loggerator
+  class Railtie < Rails::Railtie
+
+    config.before_configuration do
+      Rails.application.middleware.insert_after ActionDispatch::RequestId, Loggerator::Middleware::RequestStore
+      Rails.application.middleware.swap         ActionDispatch::RequestId, Loggerator::Middleware::RequestID
+    end
+
+    config.before_initialize do
+      [ ActionView::Base,
+        ActiveRecord::Base,
+        ActionMailer::Base,
+        ActionController::Base ].each do |c|
+
+        c.include Loggerator
+      end
+    end
+
+  end
+end

data/lib/loggerator/request_store.rb

@@ -0,0 +1,24 @@
+module Loggerator
+  module RequestStore
+    class << self
+      def clear!
+        Thread.current[:request_store] = {}
+      end
+
+      def seed(env)
+        store[:request_id] =
+          env["REQUEST_IDS"] ? env["REQUEST_IDS"].join(",") : nil
+
+        # a global context that evolves over the lifetime of the request, and is
+        # used to tag all log messages that it produces
+        store[:request_context] = {
+          request_id: store[:request_id]
+        }
+      end
+
+      def store
+        Thread.current[:request_store] ||= {}
+      end
+    end
+  end
+end

data/lib/loggerator/test.rb

@@ -0,0 +1,32 @@
+module Loggerator
+  alias_method :log_on,       :log
+  alias_method :log_error_on, :log_error
+
+  def log_off(data, &block)
+    block.call if block
+  end
+
+  def log_error_off(e, data={}, &block)
+    block.call if block
+  end
+
+  class << self
+    @@log_switch = true
+
+    def turn_log(on_or_off)
+      return unless %i[on off].include?(on_or_off.to_sym)
+      alias_method :log,       :"log_#{on_or_off}"
+      alias_method :log_error, :"log_error_#{on_or_off}"
+      @@log_switch = on_or_off.to_sym == :on
+    end
+
+    def log?
+      @@log_switch
+    end
+  end
+
+end
+
+unless ENV.has_key?("TEST_LOGS")
+  Loggerator.turn_log(:off)
+end

data/test/loggerator/middleware/request_id_test.rb

@@ -0,0 +1,33 @@
+require 'rack/test'
+require 'minitest/mock'
+require 'minitest/autorun'
+require 'logger'
+
+require_relative '../../../lib/loggerator'
+
+class Loggerator::Middleware::TestRequestID < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.new do
+      use Rack::Lint
+      use Loggerator::Middleware::RequestID
+
+      run ->(env) { [ 200, { }, [ 'hi' ] ] }
+    end
+  end
+
+  def test_sets_request_id
+    get '/'
+
+    assert_match ::Loggerator::Middleware::RequestID::UUID_PATTERN,
+      last_request.env['REQUEST_ID']
+  end
+
+  def test_sets_request_ids
+    get '/'
+
+    assert_match ::Loggerator::Middleware::RequestID::UUID_PATTERN,
+      last_request.env['REQUEST_IDS'].first
+  end
+end

data/test/loggerator/middleware/request_store_test.rb

@@ -0,0 +1,40 @@
+require 'rack/test'
+require 'minitest/mock'
+require 'minitest/autorun'
+require 'logger'
+
+require_relative '../../../lib/loggerator'
+
+class Loggerator::Middleware::TestRequestStore < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.new do
+      use Rack::Lint
+      use Loggerator::Middleware::RequestStore
+
+      run ->(env) { [ 200, { }, [ 'hi' ] ] }
+    end
+  end
+
+  def test_clears_the_store
+    Thread.current[:request_store] = { something_added_before: 'bar' }
+
+    get '/'
+
+    assert_nil Thread.current[:request_store][:something_added_before]
+  end
+
+  def test_seeds_the_store
+    Thread.current[:request_store] = {}
+
+    get '/'
+
+    assert_equal Thread.current[:request_store], {
+      request_id: nil,
+      request_context: {
+        request_id: nil
+      }
+    }
+  end
+end

data/test/loggerator/request_store_test.rb

@@ -0,0 +1,35 @@
+require 'minitest/autorun'
+require 'logger'
+
+require_relative '../../lib/loggerator'
+
+class Loggerator::TestRequestStore < Minitest::Test
+  def setup
+    # flush request store
+    Thread.current[:request_store] = {}
+
+    @env = {
+      'REQUEST_ID' => 'abc',
+      'REQUEST_IDS' => %w[ abc def ]
+    }
+  end
+
+  def test_seeds_request_id
+    Loggerator::RequestStore.seed(@env)
+
+    assert_equal 'abc,def', Loggerator::RequestStore.store[:request_id]
+  end
+
+  def test_seeds_request_context
+    Loggerator::RequestStore.seed(@env)
+
+    assert_equal 'abc,def', Loggerator::RequestStore.store[:request_context][:request_id]
+  end
+
+  def test_is_cleared_by_clear!
+    Loggerator::RequestStore.seed(@env)
+    Loggerator::RequestStore.clear!
+
+    assert_nil Loggerator::RequestStore.store[:request_id]
+  end
+end

data/test/loggerator_test.rb

@@ -0,0 +1,73 @@
+require 'minitest/autorun'
+require 'logger'
+
+require_relative '../lib/loggerator'
+
+class TestLoggerator < Minitest::Test
+  include Loggerator
+
+  def setup
+    # flush request store
+    Thread.current[:request_store] = {}
+
+    self.default_context = {}
+  end
+
+  def test_logs_in_structured_format
+    out, err = capture_subprocess_io do
+      log(foo: "bar", baz: 42)
+    end
+
+    assert_equal out, "foo=bar baz=42\n"
+    assert_equal err, ''
+  end
+
+  def test_re_raises_errors
+    assert_raises(RuntimeError) do
+      capture_subprocess_io do
+        log(foo: 'bar') { raise RuntimeError }
+      end
+    end
+  end
+
+  def test_supports_blocks_to_log_stages_and_elapsed
+    out, _ = capture_subprocess_io do
+      log(foo: 'bar') { }
+    end
+
+    assert_equal out, "foo=bar at=start\n" \
+      + "foo=bar at=finish elapsed=0.000\n"
+  end
+
+  def test_merges_default_context_with_eq
+    # testing both methods
+    self.default_context = { app: 'my_app' }
+
+    out, _ = capture_subprocess_io do
+      log(foo: 'bar')
+    end
+
+    assert_equal out, "app=my_app foo=bar\n"
+  end
+
+  def test_suports_a_log_context
+    out, _ = capture_subprocess_io do
+      self.log_context(app: 'my_app') do
+        log(foo: 'bar')
+      end
+    end
+
+    assert_equal out, "app=my_app foo=bar\n"
+  end
+
+  def test_log_context_merged_with_default_context
+    out, _ = capture_subprocess_io do
+      self.default_context = { app: 'my_app' }
+      self.log_context(foo: 'bar') do
+        log(bah: 'boo')
+      end
+    end
+
+    assert_equal out, "app=my_app foo=bar bah=boo\n"
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: loggerator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joshua Mervine
+- Reid MacDonald
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-23 00:00:00.000000000 Z
+dependencies: []
+description: Simple web application extension for logging, following the 12factor
+  pattern.
+email:
+- joshua@mervine.net
+- reidmix@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/loggerator/log_generator.rb
+- lib/generators/templates/log.rb.erb
+- lib/loggerator.rb
+- lib/loggerator/loggerator.rb
+- lib/loggerator/metrics.rb
+- lib/loggerator/middleware.rb
+- lib/loggerator/middleware/request_id.rb
+- lib/loggerator/middleware/request_store.rb
+- lib/loggerator/namespace.rb
+- lib/loggerator/rails.rb
+- lib/loggerator/request_store.rb
+- lib/loggerator/test.rb
+- test/loggerator/middleware/request_id_test.rb
+- test/loggerator/middleware/request_store_test.rb
+- test/loggerator/request_store_test.rb
+- test/loggerator_test.rb
+homepage: https://github.com/heroku/loggerator
+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.5.1
+signing_key: 
+specification_version: 4
+summary: 'loggerator: A Log Helper'
+test_files:
+- test/loggerator/middleware/request_id_test.rb
+- test/loggerator/middleware/request_store_test.rb
+- test/loggerator/request_store_test.rb
+- test/loggerator_test.rb