rackstash 0.0.1 → 0.1.0

data/lib/rackstash/version.rb

@@ -1,3 +1,3 @@
 module Rackstash
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/tasks/rackstash.rb

@@ -0,0 +1,9 @@
+desc "Execute a sub-task in a rackstash log scope"
+task :with_rackstash, [:task] do |t, args|
+  Rake::Task[:environment].invoke if Rake::Task[:environment]
+
+  Rackstash.tags |= ["rake", "rake::#{args[:task]}"]
+  Rackstash.with_log_buffer do
+    Rake::Task[args[:task]].invoke
+  end
+end

data/rackstash.gemspec

@@ -1,35 +1,35 @@
-# coding: utf-8
-# Copyright 2016 Holger Just
-#
-# This software may be modified and distributed under the terms
-# of the MIT license. See the LICENSE.txt file for details.
-
+# -*- encoding: utf-8 -*-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rackstash/version'
 
-Gem::Specification.new do |spec|
-  spec.name          = 'rackstash'
-  spec.version       = Rackstash::VERSION
-  spec.authors       = ['Holger Just']
+Gem::Specification.new do |gem|
+  gem.name          = "rackstash"
+  gem.version       = Rackstash::VERSION
+  gem.authors       = ["Holger Just, Planio GmbH"]
+  gem.email         = ["holger@plan.io"]
+  gem.description   = %q{Making Rack and Rails logs useful}
+  gem.summary       = %q{Making Rack and Rails logs useful}
+  gem.homepage      = "https://github.com/planio-gmbh/rackstash"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
 
-  spec.summary       = 'This is a placeholder for now'
-  spec.description   = <<-TXT.tap { |s| s.gsub!(/\s+|\n/, ' ').strip! }
-    This is just a placeholder for now. Please have a look at
-    https://github.com/meineerde/rackstash for any progress on releasing this
-    gem.
-  TXT
-  spec.homepage      = 'https://github.com/meineerde/rackstash'
-  spec.license       = 'MIT'
+  gem.add_runtime_dependency "logstash-event", "< 1.2.0"
+  gem.add_runtime_dependency "activesupport"
+  gem.add_runtime_dependency "thor"
 
-  spec.required_ruby_version = '>= 2.1.0'
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "json"
 
-  files = `git ls-files -z`.split("\x0")
-  spec.files         = files.reject { |f| f.match(%r{^(test|spec|feature)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  if RbConfig::CONFIG["RUBY_INSTALL_NAME"] == "rbx"
+    gem.add_runtime_dependency "rubysl", "~> 2.0"
 
-  spec.add_development_dependency 'bundler', '~> 1.11'
-  spec.add_development_dependency 'rake', '~> 10.0'
+    gem.add_development_dependency 'rubinius-coverage', '~> 2.0'
+    gem.add_development_dependency 'parser', '~> 2.1.0.pre1'
+    gem.add_development_dependency 'racc', '~> 1.4'
+  end
 end

data/test/buffered_logger_test.rb

@@ -0,0 +1,191 @@
+require 'test_helper'
+require 'rackstash/buffered_logger'
+
+require 'stringio'
+require 'json'
+
+describe Rackstash::BufferedLogger do
+  let(:log_output){ StringIO.new }
+  let(:base_logger){ Logger.new(log_output) }
+
+  def log_line
+    log_output.string.lines.to_a.last
+  end
+  def json
+    JSON.parse(log_line)
+  end
+
+  subject do
+    Rackstash::BufferedLogger.new(base_logger)
+  end
+
+  it "must be properly initialized" do
+    subject.logger.formatter.must_be_instance_of Rackstash::BufferedLogger::SimpleFormatter
+    subject.buffering?.must_equal false
+    subject.fields.must_equal nil
+    subject.tags.must_equal nil
+    subject.source.must_equal nil
+  end
+
+  describe "when passing a logger" do
+    it "delegates only defined methods" do
+      # sanity
+      base_logger.wont_respond_to :flush
+      base_logger.wont_respond_to :auto_flushing
+
+      base_logger.instance_eval{ def flush; end }
+
+      base_logger.must_respond_to :flush
+      base_logger.wont_respond_to :auto_flushing
+      subject.must_respond_to :flush
+      subject.wont_respond_to :auto_flushing
+    end
+
+    it "delegates later methods too" do
+      base_logger.wont_respond_to :auto_flushing # sanity
+      base_logger.instance_eval{ def auto_flushing; end }
+
+      base_logger.must_respond_to :auto_flushing
+      subject.must_respond_to :auto_flushing
+    end
+  end
+
+  describe "when using the Logger API" do
+    it "forwards base methods to the underlying logger" do
+      subject.logger.must_be_same_as base_logger
+
+      subject.level.must_equal base_logger.level
+      subject.progname.must_be_same_as base_logger.progname
+    end
+  end
+
+  describe "when logging unbuffered" do
+    it "supports adding log messages" do
+      subject.add nil, "log_empty"
+      json["@message"].must_equal "[UNKNOWN] log_empty"
+
+      %w[debug info warn error fatal unknown].each do |severity|
+        subject.send severity, "log_#{severity}"
+
+        tag = "[#{severity.upcase}] ".rjust(10)
+        json["@message"].must_equal "#{tag}log_#{severity}"
+      end
+    end
+
+    it "supports the << method" do
+      subject << "Hello World"
+      log_output.string.must_equal "Hello World"
+    end
+
+    it "ignores the instruction to not log a message" do
+      subject.do_not_log!.must_equal false
+      subject.info "Hello World"
+      json["@message"].must_equal "   [INFO] Hello World"
+    end
+
+    it "includes the default fields" do
+      subject.info "Foo Bar Baz"
+
+      json = self.json
+      json.keys.sort.must_equal %w[@fields @message @source @tags @timestamp]
+      json["@fields"].keys.sort.must_equal %w[log_id pid]
+
+      json["@fields"]["pid"].must_equal Process.pid
+      json["@fields"]["log_id"].must_match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/)
+      json["@message"].must_equal "   [INFO] Foo Bar Baz"
+      json["@source"].must_be_nil
+      json["@tags"].must_equal []
+      # Timestamp is less than 2 seconds ago
+      timestamp_range = ((Time.now-2)..Time.now)
+      method = timestamp_range.respond_to?(:cover?) ? :cover? : :===
+      timestamp_range.must_be method, Time.parse(json["@timestamp"])
+    end
+
+    it "allows to log nil" do
+      subject.info nil
+      json["@message"].must_equal "   [INFO] "
+    end
+
+    it "allows to log numerics" do
+      subject.info 12.123
+      json["@message"].must_equal "   [INFO] 12.123"
+    end
+
+    it "allows to set a source" do
+      subject.source = "BufferedLoggerTest"
+      subject.info nil
+      json["@source"].must_equal "BufferedLoggerTest"
+    end
+  end
+
+  describe "when using a buffer" do
+    it "should buffer logs" do
+      subject.with_buffer do
+        subject.info("Hello")
+        log_output.string.must_be_empty
+        subject.info("World")
+      end
+
+      json["@message"].must_equal "   [INFO] Hello\n   [INFO] World"
+    end
+
+    it "can set additional tags" do
+      subject.with_buffer do
+        subject.tags << :foo
+        subject.info("Hello")
+      end
+
+      json["@tags"].must_equal ["foo"]
+      json["@message"].must_equal "   [INFO] Hello"
+    end
+
+    it "can set additional fields" do
+      subject.with_buffer do
+        subject.fields[:foo] = :bar
+        subject.info("Hello")
+      end
+
+      json["@fields"]["foo"].must_equal "bar"
+      json["@message"].must_equal "   [INFO] Hello"
+    end
+
+    it "can overwrite automatically filled fields" do
+      subject.with_buffer do
+        subject.fields[:pid] = "foobarbaz"
+        subject.info("Hello")
+      end
+
+      json["@fields"]["pid"].must_equal "foobarbaz"
+      json["@message"].must_equal "   [INFO] Hello"
+    end
+
+    it "captures exceptions" do
+      exception = Class.new(StandardError) do
+        def self.name
+          "SomethingWrongError"
+        end
+      end
+
+      proc do
+        subject.with_buffer do
+          raise exception, "Something is wrong"
+        end
+      end.must_raise(exception)
+
+      json["@message"].must_equal ""
+      json["@fields"]["error"].must_equal "SomethingWrongError"
+      json["@fields"]["error_message"].must_equal "Something is wrong"
+      json["@fields"]["error_backtrace"].must_match(/\A#{__FILE__}:\d+/)
+      json["@fields"]["error_backtrace"].must_match(/^#{File.expand_path("../../lib/rackstash/buffered_logger.rb", __FILE__)}:\d+:in `with_buffer'$/)
+    end
+
+    it "doesn't log anything when using do_not_log!" do
+      subject.with_buffer do
+        subject.do_not_log!.must_equal true
+        subject.info "Hello World"
+      end
+
+      log_line.must_be :nil?
+    end
+  end
+end

data/test/log_subscriber_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+require 'rackstash'
+
+if Rackstash.framework == "rails3"
+  require 'rackstash/log_subscriber'
+  require 'active_support/notifications'
+
+  describe Rackstash::LogSubscriber do
+    let(:log_output){ StringIO.new }
+    let(:base_logger){ Logger.new(log_output) }
+    let(:logger){ Rackstash::BufferedLogger.new(base_logger) }
+
+    let(:flush_and_pop_buffer){ logger.flush_and_pop_buffer }
+    let(:json) do
+      flush_and_pop_buffer
+
+      JSON.parse(log_output.string.lines.to_a.last)
+    end
+
+    let(:subscriber){ Rackstash::LogSubscriber.new }
+    let(:event) do
+      now = Time.now
+      duration = 123 # milliseconds
+      ActiveSupport::Notifications::Event.new(
+        "process_action.action_controller", now, now + (duration.to_f / 1000), 2, {
+          :status => 200, :format => "application/json", :method => "GET", :path => "/home?foo=bar",
+          :params => {
+            "controller" => "home", "action" => "index", "foo" => "bar"
+          }, :db_runtime => 0.02, :view_runtime => 0.01
+        }
+      )
+    end
+
+    let(:redirect) do
+      ActiveSupport::Notifications::Event.new(
+        'redirect_to.action_controller', Time.now, Time.now, 1, :location => 'http://example.com', :status => 302
+      )
+    end
+
+    before do
+      @original_rails_logger = Rails.logger
+      Rails.logger = logger
+      logger.push_buffer
+    end
+    after do
+      flush_and_pop_buffer
+      Rails.logger = @original_rails_logger
+    end
+
+    describe "#redirect_to" do
+      it "should store the location in a thread local variable" do
+        subscriber.redirect_to(redirect)
+        Thread.current[:rackstash_location].must_equal "http://example.com"
+      end
+    end
+
+    describe "#process_action" do
+      it "includes the controller and action" do
+        subscriber.process_action(event)
+        json["@fields"]["controller"].must_equal "home"
+        json["@fields"]["action"].must_equal "index"
+      end
+
+      it "includes the duration" do
+        subscriber.process_action(event)
+        json["@fields"]["duration"].must_be_within_epsilon 123
+      end
+
+      it "should include the view rendering time" do
+        subscriber.process_action(event)
+        json["@fields"]["view"].must_be_within_epsilon 0.01
+      end
+
+      it "should include the database rendering time" do
+        subscriber.process_action(event)
+        json["@fields"]["db"].must_be_within_epsilon 0.02
+      end
+
+      it "should add a 500 status when an exception occurred" do
+        event.payload[:status] = nil
+        event.payload[:exception] = ['AbstractController::ActionNotFound', 'Route not found']
+        subscriber.process_action(event)
+
+        json["@fields"]["error"].must_equal "AbstractController::ActionNotFound"
+        json["@fields"]["error_message"].must_equal "Route not found"
+      end
+    end
+  end
+end

data/test/rackstash_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+require 'rackstash'
+
+describe Rackstash do
+  let(:log_output){ StringIO.new }
+  let(:base_logger){ Logger.new(log_output) }
+  def json
+    JSON.parse(log_output.string.lines.to_a.last)
+  end
+
+  subject do
+    Rackstash::BufferedLogger.new(base_logger)
+  end
+
+  describe "fields" do
+    after do
+      Rackstash.fields = HashWithIndifferentAccess.new
+    end
+
+    it "can be defined as a Hash" do
+      Rackstash.fields = {:foo => :bar}
+      Rackstash.fields.must_be_instance_of HashWithIndifferentAccess
+
+      subject.info("foo")
+      json["@fields"]["foo"].must_equal "bar"
+    end
+
+    it "can be defined as a proc" do
+      Rackstash.fields = proc do
+        {:foo => :baz}
+      end
+
+      subject.info("foo")
+      json["@fields"]["foo"].must_equal "baz"
+    end
+
+    it "can be defined as a lambda" do
+      Rackstash.fields = lambda do
+        {:foo => :baz}
+      end
+
+      subject.info("foo")
+      json["@fields"]["foo"].must_equal "baz"
+    end
+  end
+
+  describe "request_fields" do
+    after do
+      Rackstash.request_fields = HashWithIndifferentAccess.new
+    end
+
+    let(:controller) do
+      controller = Class.new(Object){attr_accessor :status}.new
+      controller.status = "running"
+      controller
+    end
+
+    it "won't be included in unbuffered mode" do
+      Rackstash.request_fields = {:foo => :bar}
+
+      subject.info("foo")
+      json["@fields"].keys.wont_include "foo"
+    end
+
+    it "can be defined as a hash" do
+      Rackstash.request_fields = {:foo => :bar}
+
+      Rackstash.request_fields(controller).must_be_instance_of HashWithIndifferentAccess
+      Rackstash.request_fields(controller).must_equal({"foo" => :bar})
+
+      # TODO: fake a real request and ensure that the field gets set in the log output
+    end
+
+    it "can be defined as a proc" do
+      Rackstash.request_fields = proc do |controller|
+        {
+          :foo => :bar,
+          :status => @status,
+          :instance_status => controller.status
+        }
+      end
+
+      Rackstash.request_fields(controller).must_be_instance_of HashWithIndifferentAccess
+      Rackstash.request_fields(controller).must_equal({"foo" => :bar, "status" => "running", "instance_status" => "running"})
+
+      # TODO: fake a real request and ensure that the field gets set in the log output
+    end
+
+    it "can be defined as a lambda" do
+      Rackstash.request_fields = lambda do |controller|
+        {
+          :foo => :bar,
+          :status => @status,
+          :instance_status => controller.status
+        }
+      end
+
+      Rackstash.request_fields(controller).must_be_instance_of HashWithIndifferentAccess
+      Rackstash.request_fields(controller).must_equal({"foo" => :bar, "status" => "running", "instance_status" => "running"})
+
+      # TODO: fake a real request and ensure that the field gets set in the log output
+    end
+  end
+end