logging_elf 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: edd72f1b9a67df249d70aa481c0ddb1eb8e77674
+  data.tar.gz: bdb49524283475272dc2fc46b3a039cda6ae802e
+SHA512:
+  metadata.gz: 4dfd2ae5addd66e46cdc1d769a93fbe77b098acef96e9e8e64763c8ffc309feb5689a08d9d8fbb7fd159d05f656e98bb1aace67633df7578ae5c2c3565b1cf32
+  data.tar.gz: 4aca640abc72f3754bf12182dccc7429833b8be8ab5afb2f0781d6906eb8164bc18b6dc16b2173be1f7da7486abbeec209c421312f61412cdca45df2ce86970a

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 2.0.0
+  - 2.1
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in logging_elf.gemspec
+gemspec
+
+group 'development' do
+  gem 'guard'
+  gem 'guard-rspec'
+end

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^lib/(.+)\.rb$}) do |m|
+    ["spec/#{m[1]}_spec.rb", "spec/integrations/entire_flow_spec.rb"]
+  end
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jeff Deville
+
+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,30 @@
+# LoggingElf
+[![Build Status](https://travis-ci.org/promptworks/logging_elf.png?branch=master)](https://travis-ci.org/promptworks/logging_elf)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'logging_elf'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logging_elf
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/logging_elf/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/lib/logging_elf.rb

@@ -0,0 +1,16 @@
+require 'active_model'
+require 'active_support/core_ext/hash'
+require 'virtus'
+require 'logging'
+require 'gelf'
+
+require "logging_elf/version"
+require "logging_elf/config"
+require "logging_elf/gelf_data"
+require "logging_elf/gelf_appender"
+require "logging_elf/tracing_logger"
+require "logging_elf/lograge_formatter"
+require "logging_elf/uncaught_exceptions_middleware"
+
+module LoggingElf
+end

data/lib/logging_elf/config.rb

@@ -0,0 +1,14 @@
+module LoggingElf
+  class << self
+    attr_accessor :config
+  end
+
+  def self.configure
+    self.config ||= Configuration.new
+    yield(config)
+  end
+
+  class Configuration
+    attr_accessor :graylog_host, :graylog_port, :trace_hash, :host
+  end
+end

data/lib/logging_elf/gelf_appender.rb

@@ -0,0 +1,22 @@
+module Logging::Appenders
+  def self.gelf(*args)
+    LoggingElf::GelfAppender.new(*args)
+  end
+end
+
+module LoggingElf
+  class GelfAppender < ::Logging::Appender
+    attr_accessor :logger
+    def initialize(opts = {})
+      super "gelf", opts
+      @logger = GELF::Logger.new(
+        opts[:graylog_host], opts[:graylog_port], "WAN")
+    end
+
+    def write(event)
+      return if event.data.is_a?(String) && event.data.blank?
+      message = GelfData.from_log_event event
+      @logger.notify! message.to_gelf
+    end
+  end
+end

data/lib/logging_elf/gelf_data.rb

@@ -0,0 +1,85 @@
+# http://graylog2.org/gelf#specs
+# Some appenders can output to different formats, but this isn't
+# one of them, so it's simplified as a result.
+
+module LoggingElf
+  class GelfData
+    include Virtus.model
+    include ActiveModel::Validations
+
+    attribute :host, String
+    attribute :version, String, default: "1.0"
+    attribute :short_message, String
+    attribute :full_message, String
+    # UNIX microsecond timestamp, should be set by client!
+    attribute :timestamp, Integer
+    attribute :level, Integer
+    # Have to set this way even though facility is deprecated
+    # because gelf-rb will overwrite it otherwise
+    attribute :facility, String
+    attr_accessor :additional_fields
+    validates :host, :version, :short_message, presence: true
+
+    def initialize(gelf_data = {})
+      super
+      self.additional_fields ||= {}
+      self.host ||= LoggingElf.config.host if LoggingElf.config
+      return if gelf_data.nil?
+      add_fields(gelf_data)
+    end
+
+    def to_gelf
+      required_gelf_attributes.merge additional_fields
+    end
+
+    def required_gelf_attributes
+      attributes
+    end
+
+    def self.from_log_event(log_event)
+      gd = GelfData.new(level: log_event.level, facility: log_event.logger)
+      case log_event.data
+      when String     then gd.short_message = log_event.data
+      when Hash       then add_hash_data(gd, log_event.data)
+      when Exception  then add_exception_details gd, log_event.data
+      end
+      set_backtrace_data gd, log_event
+      gd
+    end
+
+    def self.add_hash_data(gelf_data, data)
+      gelf_data.add_fields(data)
+
+      unless gelf_data.short_message
+        gelf_data.short_message = data[:message] || data["message"]
+        if gelf_data.short_message.blank?
+          gelf_data.short_message = data.map { |k, v| "#{k}='#{v}'" }.join(" ")
+        end
+      end
+    end
+
+    def add_fields(params_hash)
+      params_hash.each do |key, value|
+        if required_gelf_attributes.keys.include? key
+          send("#{key}=", value)
+        else
+          additional_fields["_#{key}".to_sym] = value
+        end
+      end
+    end
+
+    def self.add_exception_details(gelf_data, error)
+      gelf_data.full_message = gelf_data.short_message =
+        "<#{error.class.name}> #{error.message}"
+      if error.backtrace
+        gelf_data.full_message << "\n\t" << error.backtrace.join("\n\t")
+      end
+    end
+
+    def self.set_backtrace_data(gelf_data, event)
+      gelf_data.add_fields(file: event.file) if event.file
+      gelf_data.add_fields(file: event.line) if event.line
+      gelf_data.add_fields(file: event.method) if event.method
+    end
+  end
+end

data/lib/logging_elf/lograge_formatter.rb

@@ -0,0 +1,8 @@
+module LoggingElf
+  class LogrageFormatter
+    def call(data)
+      data[:message] = data[:path]
+      data
+    end
+  end
+end

data/lib/logging_elf/tracing_logger.rb

@@ -0,0 +1,80 @@
+module LoggingElf
+  class TracingLogger
+    extend Forwardable
+    def_delegators :@logger, :<<, :<=>, :_dump_configuration, :_meta_eval,
+      :add, :add_appenders, :additive, :additive=, :appenders, :appenders=,
+      :clear_appenders, :inspect, :level, :level=, :name, :parent, :_setup,
+      :remove_appenders, :trace, :trace=, :write, :formatter, :root, :config
+
+    Logging.init
+
+    def_delegators :@logger,
+      *Logging::LEVELS.map { |name, _| "#{name}?".to_sym }
+
+    Logging::LEVELS.each do |name, _|
+      define_method name.to_sym do |data = nil|
+        begin
+          # data = yield if block_given?
+          return if data.nil?
+          data = append_trace_info(data)
+          @logger.send(name.to_sym, data)
+        rescue => err
+          p err
+          pp err.backtrace
+        end
+      end
+    end
+
+    def initialize(logger, &trace_hash)
+      @logger = Logging::Logger.new logger if logger.is_a? String
+      self.trace_hash = if block_given?
+                          trace_hash
+                        elsif LoggingElf.config.trace_hash
+                          LoggingElf.config.trace_hash
+                        else
+                          fail "TracingLogger cannot be created with no" \
+                            " mechanism for appending trace data"
+                        end
+    end
+
+    attr_writer :trace_hash
+    def trace_hash
+      hash = if @trace_hash.respond_to?(:call)
+               @trace_hash.call
+             else
+               @trace_hash
+             end
+
+      hash || {}
+    end
+
+    def exception_data(data)
+      {
+        error_object: data,
+        backtrace: data.backtrace,
+        short_message: "Exception: #{data.message}",
+        message: data.message,
+        is_exception: true
+      }
+    end
+
+    def default_data(data)
+      {
+        short_message: "Unknown thing to log",
+        message: data.inspect
+      }
+    end
+
+    def append_trace_info(data)
+      data = case data
+             when Hash then data
+             when Exception then exception_data(data)
+             when String then { message: data }
+             when nil then return
+             else
+               default_data(data)
+             end
+      data.merge(trace_hash)
+    end
+  end
+end

data/lib/logging_elf/uncaught_exceptions_middleware.rb

@@ -0,0 +1,26 @@
+module LoggingElf
+  class UncaughtExceptionsMiddleware
+    attr_accessor :logger
+    def initialize(app, args = {})
+      self.logger = args[:logger]
+      @app = app
+    end
+
+    def call(env)
+      begin
+        response = @app.call env
+      rescue => err
+        logger.error err
+        raise err
+      end
+      log_rack_exceptions(env)
+      response
+    end
+
+    private
+
+    def log_rack_exceptions(env)
+      logger.error env['rack.exception'] if env['rack.exception']
+    end
+  end
+end

data/lib/logging_elf/version.rb

@@ -0,0 +1,3 @@
+module LoggingElf
+  VERSION = "0.0.1"
+end

data/logging_elf.gemspec

@@ -0,0 +1,30 @@
+# rubocop:disable RegexpLiteral
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'logging_elf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "logging_elf"
+  spec.version       = LoggingElf::VERSION
+  spec.authors       = ["Jeff Deville"]
+  spec.email         = ["jeffdeville@gmail.com"]
+  spec.summary       = "Logging, Tracing, and Gelf Logging for rails"
+  spec.description   = "Logging, Tracing, and Gelf Logging for rails"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "logging", "~> 1.8"
+  spec.add_dependency "virtus", "~> 1.0"
+  spec.add_dependency "activemodel"
+  spec.add_dependency "gelf"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.0'
+end

data/spec/integrations/entire_flow_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+class FakeGelfNotifier
+  attr_accessor :logs
+  def initialize
+    self.logs = []
+  end
+
+  def notify!(data)
+    logs << data
+  end
+end
+
+describe "Tracing all the way through" do
+  let(:notifier) do
+    # Lets us look at what was sent to the appenders
+    FakeGelfNotifier.new
+  end
+
+  let(:trace_hash) { { browser_id: "browser_id" } }
+
+  let(:gelf_data_hash) { notifier.logs.last }
+
+  before do
+    LoggingElf.configure do |config|
+      config.trace_hash = -> { trace_hash }
+      config.host = "host"
+    end
+
+    logger = LoggingElf::TracingLogger.new("test")
+    logger.class.name.should eq "LoggingElf::TracingLogger"
+    appender = Logging::Appenders.gelf
+    appender.logger = notifier
+    logger.add_appenders(appender)
+    logger.info log_subject
+  end
+
+  shared_examples_for "gelf data output" do
+    let(:reconstituted_gelf_data) do
+      gelf_data_hash.select { |k, _| k.to_s.start_with?("_") }.each do |k, v|
+        gelf_data_hash["#{k.slice(1..-1)}"] = gelf_data_hash.delete k
+      end
+      LoggingElf::GelfData.new gelf_data_hash
+    end
+
+    specify { expect(reconstituted_gelf_data).to be_valid }
+  end
+
+  describe "logging a string" do
+    let(:log_subject) { "string message" }
+    it_should_behave_like "gelf data output"
+    specify { expect(gelf_data_hash[:short_message]).to eq "string message" }
+    specify { expect(gelf_data_hash[:_browser_id]).to eq "browser_id" }
+  end
+
+  describe "logging a hash" do
+    let(:log_subject) { { foo: 'bar' } }
+    it_should_behave_like "gelf data output"
+  end
+
+  describe "logging an exception" do
+    let(:log_subject) { RuntimeError.new "Boom" }
+    it_should_behave_like "gelf data output"
+  end
+
+end

data/spec/logging_elf/gelf_data_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+include Logging
+include LoggingElf
+
+describe GelfData do
+  describe ".valid?"  do
+    it "should ensure validity of the data object" do
+      gd = GelfData.new
+      gd.version = nil
+      gd.should_not be_valid
+      gd.errors.count.should eq 3
+
+      gd.host = "host"
+      gd.should_not be_valid
+      gd.errors.count.should eq 2
+
+      gd.version = "12"
+      gd.should_not be_valid
+      gd.errors.count.should eq 1
+
+      gd.short_message = "short message"
+      gd.should be_valid
+    end
+
+    it "should pull the host from the LoggingElf.config if not specified" do
+      LoggingElf.configure do |config|
+        config.host = "host"
+      end
+      gd = GelfData.new
+      gd.host.should == "host"
+    end
+  end
+
+  describe "#add_fields" do
+    let(:gd) { GelfData.new }
+
+    it "sets a required attribute" do
+      gd.add_fields(host: "localhost")
+
+      gd.host.should eq "localhost"
+    end
+
+    it "adds non-required fields to the additional_fields hash" do
+      gd.add_fields(extra_field: "extra value")
+
+      gd.additional_fields[:_extra_field].should eq "extra value"
+    end
+  end
+
+  describe "initialize" do
+    it "should set standard params via constructor" do
+      gd = GelfData.new(
+        host: "host",
+        version: "123",
+        short_message: "short_message",
+        full_message: "full_message",
+        timestamp: 123,
+        level: 1
+      )
+      gd.host.should eq "host"
+      gd.version.should eq '123'
+      gd.short_message.should eq 'short_message'
+      gd.full_message.should eq 'full_message'
+      gd.timestamp.should eq 123
+      gd.level.should eq 1
+    end
+  end
+
+  describe "from_log_event" do
+    let(:event) { LogEvent.new("testing", 3, data, trace) }
+    let(:trace) { nil }
+    subject { GelfData.from_log_event event }
+
+    shared_examples_for "all gelf data" do
+      specify { expect(subject.short_message).to_not be_blank }
+    end
+
+    context "with a hash" do
+      let(:data) do
+        { extra_field: "extra value", facility: "facility" }.merge(message)
+      end
+      %w[message short_message].each do |field_name|
+        %i[to_s to_sym].each do |field_name_format|
+          context "with a #{field_name} #{field_name_format}" do
+            let(:message) do
+              { field_name.send(field_name_format) => "message" }
+            end
+            specify do
+              subject.additional_fields[:_extra_field].should eq "extra value"
+            end
+            it_should_behave_like "all gelf data"
+          end
+        end
+      end
+
+      context "with no discernible message" do
+        let(:message) { {} }
+        specify do
+          expect(subject.short_message).to eq(
+            "extra_field='extra value' facility='facility'")
+        end
+        it_should_behave_like "all gelf data"
+      end
+    end
+
+    context "with a string" do
+      let(:data) { "I am a string" }
+      specify { expect(subject.short_message).to eq data }
+    end
+
+    context "with an exception" do
+      let(:data) { { error_object: RuntimeError.new("hi") } }
+      it_should_behave_like "all gelf data"
+
+      context "and a trace" do
+        let(:trace) { caller }
+      end
+    end
+  end
+
+  describe "to_gelf" do
+    let(:gd) do
+      GelfData.new(
+        host: "host",
+        short_message: "short_message",
+        full_message: "full_message",
+        timestamp: 123,
+        level: 1,
+        line: 12,
+        file: "file",
+        facility: "facility",
+        other_data: "other_data"
+      )
+    end
+
+    it "adds a version" do
+      gd.to_gelf.keys.should include(:version)
+    end
+
+    it "prepends an underscore to some key names" do
+      keys = gd.to_gelf.keys
+      keys.should include(:_line, :_file, :_other_data)
+      keys.should_not include(:line, :file, :other_data)
+    end
+  end
+end

data/spec/logging_elf/tracing_logger_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+include Logging
+include LoggingElf
+
+describe LoggingElf::TracingLogger do
+  let(:fake_appender) do
+    # Lets us look at what was sent to the appenders
+    class FakeAppender < ::Logging::Appender
+      attr_accessor :logs
+      def initialize(name, opts)
+        super(name, opts)
+        self.logs = []
+      end
+
+      def write(data)
+        logs << data
+      end
+    end
+    FakeAppender.new("test",  level: 1)
+  end
+
+  let(:trace_hash) do
+    {
+      browser_id: "browser_id",
+      session_id: "session_id",
+      request_method: "request.method",
+      path: "request.path"
+    }
+  end
+
+  let!(:result) do
+    subject.info data
+    recent_event = fake_appender.logs.last
+    recent_event.nil? ? nil : recent_event.data
+  end
+
+  shared_examples_for "log info should include trace data" do
+    it "should include the trace hash" do
+      result[:browser_id].should eq trace_hash[:browser_id]
+      result[:session_id].should eq trace_hash[:session_id]
+      result[:request_method].should eq trace_hash[:request_method]
+      result[:path].should eq trace_hash[:path]
+    end
+  end
+
+  subject do
+    logger = TracingLogger.new("test") { trace_hash }
+    logger.appenders = fake_appender
+    logger
+  end
+
+  context "logging nil" do
+    let(:data) { nil }
+    specify { expect(result).to be_nil }
+  end
+
+  context "logging a hash" do
+    let(:data) do
+      {
+        field1: "field1",
+        field2: "field2"
+      }
+    end
+    it_should_behave_like "log info should include trace data"
+    it "should include the original data as well" do
+      result[:field1].should eq data[:field1]
+      result[:field2].should eq data[:field2]
+    end
+  end
+
+  context "logging a string" do
+    let(:data) { "I am a Log Event" }
+    specify { expect(result[:message]).to eq data }
+    it_should_behave_like "log info should include trace data"
+  end
+
+  context "logging an exception" do
+    let(:data) { RuntimeError.new "Hi" }
+    it_should_behave_like "log info should include trace data"
+    specify { result[:is_exception].should be_truthy }
+    specify { result[:error_object].should eq data }
+    specify { result[:backtrace].should eq data.backtrace }
+    specify { result[:message].should eq "Hi" }
+    specify { result[:short_message].should eq "Exception: Hi" }
+  end
+
+  context "logging an unknown type" do
+    let(:data) { OpenStruct.new(jeff: "was here ") }
+    it_should_behave_like "log info should include trace data"
+    it "should still log something" do
+      result[:message].should eq data.inspect
+    end
+  end
+
+end

data/spec/logging_elf/uncaught_exceptions_middleware_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe LoggingElf::UncaughtExceptionsMiddleware do
+  describe "call" do
+    let(:logger) { FakeLogger.new }
+    let(:last_msg) { logger.logs.last }
+    let(:app) { double }
+    let(:env) { { test: "test" } }
+    let(:response) { "I am the response" }
+    subject do
+      LoggingElf::UncaughtExceptionsMiddleware.new app, logger: logger
+    end
+
+    def act
+      @returned_response = subject.call env
+    end
+
+    context "no errors occurred" do
+      before do
+        app.stub(:call).with(env).and_return response
+        act
+      end
+      it 'should not have logged anything' do
+        logger.logs.count.should eq 0
+      end
+      specify { @returned_response.should_not be_nil }
+    end
+
+    context "an uncaught exception is raised" do
+      before do
+        app.stub(:call).with(env).and_raise(StandardError)
+      end
+
+      it 'should have logged the error' do
+        begin
+          act
+        # rubocop:disable HandleExceptions
+        rescue
+        # rubocop:enable HandleExceptions
+        ensure
+          logger.logs.count.should eq 1
+          last_msg.should be_a StandardError
+        end
+      end
+
+      it 're-raises the exception' do
+        expect { act }.to raise_error StandardError
+      end
+    end
+
+    context "an error is added to env['rack.exception']" do
+      before do
+        env['rack.exception'] = "I am a sad sad exception"
+        app.stub(:call).with(env).and_return response
+        act
+      end
+      it 'should have logged the error' do
+        logger.logs.count.should eq 1
+        last_msg.should eq env['rack.exception']
+      end
+      specify { @returned_response.should_not be_nil }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+require 'logging_elf'
+support_files = Dir[File.join(
+  File.expand_path("../../spec/support/**/*.rb", __FILE__)
+)]
+support_files.each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = :random
+
+  config.before(:each) do
+    LoggingElf.config = nil
+  end
+end

data/spec/support/config.rb

@@ -0,0 +1,4 @@
+LoggingElf.configure do |config|
+  config.graylog_host = "10.88.90.73"
+  config.graylog_port = 12_201
+end

data/spec/support/fake_logger.rb

@@ -0,0 +1,15 @@
+class FakeLogger
+  attr_accessor :logs
+  def initialize
+    @logs = []
+  end
+
+  def debug(obj)
+    logs << obj
+  end
+
+  alias_method :info, :debug
+  alias_method :warn, :debug
+  alias_method :error, :debug
+  alias_method :fatal, :debug
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: logging_elf
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeff Deville
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Logging, Tracing, and Gelf Logging for rails
+email:
+- jeffdeville@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/logging_elf.rb
+- lib/logging_elf/config.rb
+- lib/logging_elf/gelf_appender.rb
+- lib/logging_elf/gelf_data.rb
+- lib/logging_elf/lograge_formatter.rb
+- lib/logging_elf/tracing_logger.rb
+- lib/logging_elf/uncaught_exceptions_middleware.rb
+- lib/logging_elf/version.rb
+- logging_elf.gemspec
+- spec/integrations/entire_flow_spec.rb
+- spec/logging_elf/gelf_data_spec.rb
+- spec/logging_elf/tracing_logger_spec.rb
+- spec/logging_elf/uncaught_exceptions_middleware_spec.rb
+- spec/spec_helper.rb
+- spec/support/config.rb
+- spec/support/fake_logger.rb
+homepage: ''
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Logging, Tracing, and Gelf Logging for rails
+test_files:
+- spec/integrations/entire_flow_spec.rb
+- spec/logging_elf/gelf_data_spec.rb
+- spec/logging_elf/tracing_logger_spec.rb
+- spec/logging_elf/uncaught_exceptions_middleware_spec.rb
+- spec/spec_helper.rb
+- spec/support/config.rb
+- spec/support/fake_logger.rb
+has_rdoc: