paul_bunyan 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c8be4508c3bf748cc21adad0846a24d822dbea2
+  data.tar.gz: bee128e2be543d84c4ae31571949385c53c74a6f
+SHA512:
+  metadata.gz: 49db1d3690ffdf9756b57200227e1ddb797dd867064fb3c4f63e6264e1babd8737473986abd01497a02a22b962ad17bcbfe4a4ad91ec7431c499307304c8363d
+  data.tar.gz: a41bb6c373d12cc1a4d68e0c38524aa5bea49a6e8adc175f439fdd17c7dcf9f53e46c39f03a8a7b279702b8c9c08efa7f72a103e79975cbcb7b9fb997c6936be

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache

data/.travis.yml

@@ -0,0 +1,9 @@
+bundler_args: ''
+language: ruby
+gemfile:
+  - spec/gemfiles/40.gemfile
+  - spec/gemfiles/41.gemfile
+  - spec/gemfiles/42.gemfile
+matrix:
+  exclude:
+script: bundle exec rspec

data/Dockerfile

@@ -0,0 +1,13 @@
+FROM docker.insops.net/instructure/instructure-ruby:2.1
+MAINTAINER Tyler Pickett <tpickett@instructure.com>
+
+WORKDIR /usr/src/app
+COPY Gemfile* *.gemspec /usr/src/app/
+COPY lib/paul_bunyan/version.rb /usr/src/app/lib/paul_bunyan/
+RUN bundle install
+
+COPY . /usr/src/app
+USER root
+RUN chown -R docker:docker /usr/src/app/*
+USER docker
+CMD bundle exec wwtd --parallel

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Declare your gem's dependencies in logging.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec

data/Guardfile

@@ -0,0 +1,16 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# 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/rsspec' (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 separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Instructure Inc.
+
+MIT License
+
+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,51 @@
+# Paul Bunyan (formerly: Logging)
+
+PaulBunyan is a re-usable component with a globally accessible Logger with extra
+support for handling logging in Rails.
+
+```
+class Foo
+  include PaulBunyan
+
+  def bar
+    logger.warn "blah"
+  end
+end
+```
+
+Also included is a Railtie that overrides the default rails logger to always
+print to STDOUT as well as format the messages to JSON for machine readable
+goodness. This has been tested with Rails 4.2 but should compatible with
+Rails 3 or newer since that's when Railties were introduced.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'paul_bunyan'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install paul_bunyan
+
+## Usage
+
+### Non-Rails projects:
+
+```
+require 'paul_bunyan'
+
+include PaulBunyan::Logger
+
+PaulBunyan.set_logger(STDOUT)
+
+logger.warn "blah"
+```
+
+### Rails projects:
+
+Nothing after it's added to your Gemfile, the Railtie takes care of the rest.

data/README.rdoc

@@ -0,0 +1,3 @@
+= PaulBunyan
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+require "wwtd/tasks"
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PaulBunyan'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+task default: "wwtd"

data/bin/logging_demo

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require_relative '../lib/logging'
+
+logger = PaulBunyan.set_logger(STDOUT)
+puts "JSONFormatter"
+logger.debug("PaulBunyanDemo") { "This is my debug message" }
+logger.info("PaulBunyanDemo") { "This is my info message" }
+logger.info("PaulBunyanDemo") { {foo: "bar", baz: "qux"} }
+logger.warn("PaulBunyanDemo") { "This is my warn message" }
+begin
+  raise "heck"
+rescue => ex
+  logger.error("PaulBunyanDemo") { ex }
+end
+logger.fatal("PaulBunyanDemo") { "This is my fatal message" }

data/build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+
+docker pull docker.insops.net/instructure/instructure-ruby:2.1
+docker-compose build
+docker-compose run test

data/docker-compose.yml

@@ -0,0 +1,4 @@
+test:
+  build: .
+  volumes:
+    - "coverage:/app/coverage"

data/lib/paul_bunyan.rb

@@ -0,0 +1,70 @@
+require 'logger'
+
+require_relative 'paul_bunyan/json_formatter'
+require_relative 'paul_bunyan/level'
+require_relative 'paul_bunyan/log_relayer'
+require_relative 'paul_bunyan/text_formatter'
+require_relative 'paul_bunyan/version'
+
+require_relative 'paul_bunyan/railtie' if defined? ::Rails::Railtie
+
+# Example Usage:
+#
+#   class MyClass
+#     include PaulBunyan
+#
+#     def initialize
+#       logger.info{ "something is working!" }
+#     end
+#   end
+#
+module PaulBunyan
+  class Error < StandardError; end
+  class UnknownFormatterError < Error; end
+  class UnknownLevelError < Error; end
+
+  # The ONE method we care about.
+  def logger
+    PaulBunyan.logger
+  end
+
+  class << self
+    attr_accessor :default_formatter_type
+    PaulBunyan.default_formatter_type = :json
+
+    def logger
+      create_logger(STDOUT) unless @logger
+      @logger
+    end
+
+    def create_logger(logdev, shift_age = 0, shift_size = 1048576, formatter_type: PaulBunyan.default_formatter_type)
+      logger = Logger.new(logdev, shift_age, shift_size)
+      logger.formatter = default_formatter(formatter_type) unless formatter_type.nil?
+      add_logger(logger)
+    end
+
+    def add_logger(logger)
+      @logger ||= LogRelayer.new
+      @logger.add_logger(logger)
+      logger
+    end
+
+    def remove_logger(logger)
+      @logger.remove_logger(logger)
+    end
+
+    private def default_formatter(formatter_type)
+      case formatter_type
+      when :json
+        JSONFormatter.new
+      when :text
+        TextFormatter.new
+      else
+        fail UnknownFormatterError, "Unknown formatter type #{formatter_type}"
+      end
+    end
+  end
+end
+
+# For backwards compatibility with applications that used this prior to the rename
+Logging = PaulBunyan

data/lib/paul_bunyan/json_formatter.rb

@@ -0,0 +1,122 @@
+require 'json'
+require 'thread'
+
+module PaulBunyan
+  class JSONFormatter
+    DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S.%3N'
+
+    def call(severity, time, progname, msg)
+      metadata = {
+        "ts"       => time.utc.strftime(DATETIME_FORMAT),
+        "unix_ts"  => time.to_f,
+        "severity" => severity,
+        "pid"      => $$,
+      }
+      metadata['program'] = progname if progname
+      metadata['tags'] = current_tags unless current_tags.empty?
+
+      message_data = format_message(msg)
+
+      JSON::generate(merge_metadata_and_message(metadata, message_data)) + "\n"
+    end
+
+    def clear_tags!
+      current_tags.clear
+    end
+
+    def current_tags
+      thread_key = @thread_key ||= "logging_tagged_logging_tags:#{ Thread.current.object_id }"
+      Thread.current[thread_key] ||= []
+    end
+
+    def datetime_format=(value)
+      # intentional nop because the whole point of this formatter is
+      # to have a consistent machine parsable format :-P
+    end
+
+    def datetime_format
+      DATETIME_FORMAT
+    end
+
+    def pop_tags(count = 1)
+      current_tags.pop(count)
+    end
+
+    def push_tags(*tags)
+      tags.flatten.reject{|t| t.nil? || t.to_s.strip == '' }.tap do |clean_tags|
+        current_tags.concat(clean_tags)
+      end
+    end
+
+    def tagged(*tags)
+      clean_tags = push_tags(tags)
+      yield
+    ensure
+      pop_tags(clean_tags.size)
+    end
+
+    private
+
+    # TODO: extract all of this formatting/merging out into another class if it grows
+    def format_message(message)
+      case message
+      when Exception
+        format_exception(message)
+      when String
+        format_string(message)
+      else
+        format_generic_object(message)
+      end
+    end
+
+    def format_exception(exception)
+      # TODO: capture the exception cause if it is present and handle the case where
+      # cause isn't actually an exception (such as Parslet::ParseFailed#cause)
+      {
+        "exception.class" => exception.class.to_s,
+        "exception.backtrace" => exception.backtrace,
+        "exception.message" => exception.message,
+      }
+    end
+
+    def format_string(message)
+      { "message" => strip_ansi(message.strip) }
+    end
+
+    def format_generic_object(object)
+      if object.respond_to?(:to_h)
+        object.to_h
+      elsif object.respond_to?(:to_hash)
+        object.to_hash
+      else
+        format_string(object.inspect)
+      end
+    end
+
+    def merge_metadata_and_message(metadata, message)
+      clean_message = sanitize_message_keys(message, metadata.keys)
+      metadata.merge(clean_message)
+    end
+
+    def sanitize_message_keys(message, metadata_keys)
+      message.inject({}) { |clean, (key, value)|
+        key = key.to_s
+        if metadata_keys.include?(key)
+          clean["user.#{ key }"] = value
+        else
+          clean[key] = value
+        end
+        clean
+      }
+    end
+
+    ANSI_REGEX = /(?:\e\[|\u009b)(?:\d{1,3}(?:;\d{0,3})*)?[0-9A-MRcf-npqrsuy]/
+    def strip_ansi(value)
+      if value.respond_to?(:to_str)
+        value.to_str.gsub(ANSI_REGEX, '')
+      elsif value
+        value.gsub(ANSI_REGEX, '')
+      end
+    end
+  end
+end

data/lib/paul_bunyan/level.rb

@@ -0,0 +1,28 @@
+module PaulBunyan
+  module Level
+    LEVEL_MAP = {
+      DEBUG: Logger::DEBUG,
+      INFO: Logger::INFO,
+      WARN: Logger::WARN,
+      ERROR: Logger::ERROR,
+      FATAL: Logger::FATAL,
+      UNKNOWN: Logger::UNKNOWN
+    }.freeze
+    LOGGING_LEVEL_KEYS = LEVEL_MAP.keys.freeze
+    LOGGING_LEVELS = (Logger::DEBUG..Logger::UNKNOWN).freeze
+
+    def self.coerce_level(level)
+      coerced_level = level || Logger::DEBUG
+      if level =~ /\A\s*\d+\s*\z/
+        coerced_level = level.to_i
+      elsif level.is_a?(String) || level.is_a?(Symbol)
+        coerced_level = LEVEL_MAP[level.upcase.to_sym]
+      end
+
+      unless LOGGING_LEVELS.cover?(coerced_level)
+        fail UnknownLevelError, "Unknown logging level #{level}. Please try one of: #{LOGGING_LEVEL_KEYS.join(', ')}."
+      end
+      coerced_level
+    end
+  end
+end