timberio 1.0.0.beta1 → 1.0.0

data/lib/timber/macros/logfmt_encoder.rb

@@ -1,77 +0,0 @@
-module Timber
-  module Macros
-    # Encodes a hash into a simple logfmt string.
-    #
-    # A couple of important points:
-    #
-    # 1. This module is designed to be fast, as it is executed inline with
-    #    each log line.
-    # 2. It makes assumptions about the hash structure, and is designed
-    #    specifically for Timber. We can reduce the edge cases and improve
-    #    performance drastically.
-    class LogfmtEncoder
-      ARRAY_DELIMITER = ",".freeze
-      ARRAY_END = "]".freeze
-      ARRAY_START = "[".freeze
-      ESCAPE = "\\".freeze
-      KEY_DELIMITER = ".".freeze
-      KEY_VALUE_DELIMITER = "=".freeze
-      PAIR_DELIMITER = " ".freeze
-      STRING_WRAPPER = "\"".freeze
-      SPECIAL_KEY_CHARACTERS = [KEY_DELIMITER, PAIR_DELIMITER].freeze
-      SPECIAL_VALUE_CHARACTERS = [ARRAY_DELIMITER, ARRAY_END, ARRAY_START, ESCAPE, PAIR_DELIMITER, STRING_WRAPPER].freeze
-
-      def self.encode(hash, ancestors = [])
-        if !hash.is_a?(Hash)
-          raise ArgumentError.new("hash must be a Hash")
-        end
-        items = hash.collect do |key, value|
-          keys = ancestors + [key]
-          if value.is_a?(Hash)
-            encode(value, keys)
-          else
-            "#{encode_keys(keys)}#{KEY_VALUE_DELIMITER}#{encode_value(value)}"
-          end
-        end.flatten
-        join(*items)
-      end
-
-      def self.join(*items)
-        items.join(PAIR_DELIMITER)
-      end
-
-      private
-        def self.encode_keys(keys)
-          keys.collect { |key| encode_key(key) }.join(KEY_DELIMITER)
-        end
-
-        def self.encode_key(key)
-          key = key.to_s
-          if SPECIAL_KEY_CHARACTERS.any? { |c| key.include?(c) }
-            escape(key)
-          else
-            key
-          end
-        end
-
-        def self.encode_value(value)
-          if value.is_a?(Array)
-            values = value.collect { |v| encode_value(v) }.join(ARRAY_DELIMITER)
-            "#{ARRAY_START}#{values}#{ARRAY_END}"
-          elsif value.is_a?(String) && SPECIAL_VALUE_CHARACTERS.any? { |c| value.include?(c) }
-            escape(value)
-          else
-            value
-          end
-        end
-
-        def self.escape(value)
-          # Simple gsub that is better for performance, we do not need to handle
-          # all of the edgecases that to_json handled. #to_json is also much slower.
-          new_value = value.gsub(STRING_WRAPPER, "#{ESCAPE}#{STRING_WRAPPER}")
-          new_value.gsub!(ESCAPE, "#{ESCAPE}#{ESCAPE}")
-          "#{STRING_WRAPPER}#{new_value}#{STRING_WRAPPER}"
-        end
-    end
-  end
-end

data/lib/timber/macros.rb

@@ -1,4 +0,0 @@
-require "timber/macros/compactor"
-require "timber/macros/date_formatter"
-require "timber/macros/deep_merger"
-require "timber/macros/logfmt_encoder"

data/lib/timber/patterns/delegated_singleton.rb

@@ -1,21 +0,0 @@
-require "singleton"
-
-module Timber
-  module Patterns
-    module DelegatedSingleton
-      def self.included(klass)
-        klass.class_eval do
-          extend ClassMethods
-          include Singleton
-        end
-      end
-
-      module ClassMethods
-        private
-          def method_missing(name, *args, &block)
-            instance.send(name, *args, &block)
-          end
-      end
-    end
-  end
-end

data/lib/timber/patterns/to_json.rb

@@ -1,22 +0,0 @@
-module Timber
-  module Patterns
-    # Module to fall inline with Rail's core object crazy changes.
-    # If Rails is present, it will play nice. If not, it will work just fine.
-    module ToJSON
-      # We explicitly do not do anything with the arguments as we do not need them.
-      # We avoid the unneccssary complexity.
-      def as_json(*_args)
-        @as_json ||= Macros::Compactor.compact(json_payload).freeze
-      end
-
-      def to_json(*_args)
-        @to_json ||= as_json.to_json.freeze
-      end
-
-      private
-        def json_payload
-          raise NotImplementedError.new("#json_payload is not implemented for #{self.class}")
-        end
-    end
-  end
-end

data/lib/timber/patterns/to_logfmt.rb

@@ -1,9 +0,0 @@
-module Timber
-  module Patterns
-    module ToLogfmt
-      def to_logfmt
-        @to_logfmt ||= Macros::LogfmtEncoder.encode(as_json).freeze
-      end
-    end
-  end
-end

data/lib/timber/patterns.rb

@@ -1,3 +0,0 @@
-require "timber/patterns/delegated_singleton"
-require "timber/patterns/to_json"
-require "timber/patterns/to_logfmt"

data/lib/timber/probes/action_controller_base.rb

@@ -1,31 +0,0 @@
-module Timber
-  module Probes
-    # Wraps process_action so that we get *anu* logs written within the controller.
-    # This is superior to using process_action in ActionController::LogSubscriber.
-    class ActionControllerBase < Probe
-      module InstanceMethods
-        def process(*args)
-          request_context      = Contexts::HTTPRequests::ActionControllerSpecific.new(self)
-          organization_context = Contexts::Organizations::ActionController.new(self)
-          user_context         = Contexts::Users::ActionController.new(self)
-          response_context     = Contexts::HTTPResponses::ActionController.new(self)
-          # The order is relevant here, request_context is higher in the hierarchy
-          CurrentContext.add(request_context, organization_context, user_context, response_context) do
-            super
-          end
-        end
-      end
-
-      def initialize
-        require "action_controller"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        return true if ::ActionController::Base.include?(InstanceMethods)
-        ::ActionController::Base.send(:include, InstanceMethods)
-      end
-    end
-  end
-end

data/lib/timber/probes/active_support_log_subscriber/action_controller.rb

@@ -1,15 +0,0 @@
-module Timber
-  module Probes
-    class ActiveSupportLogSubscriber < Probe
-      module ActionController
-        def self.process_action(_log_subscriber, event, &_block)
-          context = CurrentContext.get(Contexts::HTTPResponses::ActionController)
-          if context
-            context.event = event
-          end
-          yield
-        end
-      end
-    end
-  end
-end

data/lib/timber/probes/active_support_log_subscriber/action_view.rb

@@ -1,26 +0,0 @@
-module Timber
-  module Probes
-    class ActiveSupportLogSubscriber < Probe
-      class ActionView
-        def self.render_collection(_log_subscriber, event, &_block)
-          wrap(event) { yield }
-        end
-
-        def self.render_partial(_log_subscriber, event, &_block)
-          wrap(event) { yield }
-        end
-
-        def self.render_template(_log_subscriber, event, &_block)
-          wrap(event) { yield }
-        end
-
-        private
-          def self.wrap(event, &_block)
-            context1 = Contexts::TemplateRenders::ActionView.new(event)
-            context2 = Contexts::TemplateRenders::ActionViewSpecific.new(event)
-            CurrentContext.add(context1, context2) { yield }
-          end
-      end
-    end
-  end
-end

data/lib/timber/probes/active_support_log_subscriber/active_record.rb

@@ -1,13 +0,0 @@
-module Timber
-  module Probes
-    class ActiveSupportLogSubscriber < Probe
-      module ActiveRecord
-        def self.sql(log_subscriber, event, &_block)
-          context1 = Contexts::SQLQueries::ActiveRecord.new(log_subscriber, event)
-          context2 = Contexts::SQLQueries::ActiveRecordSpecific.new(log_subscriber, event)
-          CurrentContext.add(context1, context2) { yield }
-        end
-      end
-    end
-  end
-end

data/lib/timber/probes/active_support_log_subscriber.rb

@@ -1,62 +0,0 @@
-require "timber/probes/active_support_log_subscriber/action_controller"
-require "timber/probes/active_support_log_subscriber/action_view"
-require "timber/probes/active_support_log_subscriber/active_record"
-
-module Timber
-  module Probes
-    # We want to wrap every log subscriber. Think about something like
-    # lograge. We want to add context to those logs as well, not just
-    # the internal rails log subscribers.
-    class ActiveSupportLogSubscriber < Probe
-      module ClassMethods
-        def self.included(klass)
-          klass.class_eval do
-            alias_method :_timber_old_send, :send
-
-            # Override send since the #finish method uses that to send the event.
-            # This allows us to wrap the actual method.
-            def send(method_name, *args, &block)
-              if args.first.is_a?(ActiveSupport::Notifications::Event)
-                ActiveSupportLogSubscriber.wrap(self, args.first) do
-                  _timber_old_send(method_name, *args, &block)
-                end
-              else
-                _timber_old_send(method_name, *args, &block)
-              end
-            end
-          end
-        end
-      end
-
-      class << self
-        WRAPPER_MAP = {
-          "action_controller" => ActionController,
-          "action_view"       => ActionView,
-          "active_record"     => ActiveRecord
-        }.freeze
-        EVENT_DELIMITER = ".".freeze
-
-        def wrap(log_subscriber, event, &_block)
-          event_name, namespace = event.name.split(EVENT_DELIMITER)
-          wrapper = WRAPPER_MAP[namespace]
-          if wrapper && wrapper.respond_to?(event_name)
-            wrapper.send(event_name, log_subscriber, event) { yield }
-          else
-            yield
-          end
-        end
-      end
-
-      def initialize
-        require "active_support/log_subscriber"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        return true if ::ActiveSupport::LogSubscriber.include?(ClassMethods)
-        ::ActiveSupport::LogSubscriber.send(:include, ClassMethods)
-      end
-    end
-  end
-end

data/lib/timber/probes/heroku.rb

@@ -1,30 +0,0 @@
-module Timber
-  module Probes
-    class Heroku < Probe
-      class << self
-        attr_accessor :inserted
-      end
-
-      def initialize
-        if dyno.nil?
-          raise RequirementNotMetError.new("The DYNO environment variable is not set. " +
-            "Not in the Heroku environment.")
-        end
-      end
-
-      def insert!
-        return true if self.class.inserted == true
-        context = Contexts::Servers::HerokuSpecific.new(dyno)
-        # Note we don't use a block here, this is because
-        # the context is persistent.
-        CurrentContext.add(context)
-        self.class.inserted = true
-      end
-
-      private
-        def dyno
-          ENV['DYNO']
-        end
-    end
-  end
-end

data/lib/timber/probes/logger.rb

@@ -1,31 +0,0 @@
-require "logger"
-
-module Timber
-  module Probes
-    class Logger < Probe
-      module InstanceMethods
-        def self.included(klass)
-          klass.class_eval do
-            alias_method :_timber_old_add, :add
-
-            def add(level, *args, &block)
-              if self == Config.logger
-                _timber_old_add(level, *args, &block)
-              else
-                context = Contexts::Logger.new(level, progname)
-                CurrentContext.add(context) do
-                  _timber_old_add(level, *args, &block)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def insert!
-        return true if ::Logger.include?(InstanceMethods)
-        ::Logger.send(:include, InstanceMethods)
-      end
-    end
-  end
-end

data/lib/timber/probes/rack.rb

@@ -1,36 +0,0 @@
-module Timber
-  module Probes
-    class Rack < Probe
-      class Middleware
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          context = Contexts::HTTPRequests::Rack.new(env)
-          CurrentContext.add(context) do
-            @app.call(env)
-          end
-        end
-      end
-
-      attr_reader :middleware, :insert_before
-
-      def initialize(middleware, insert_before)
-        if middleware.nil?
-          raise RequirementNotMetError.new("The middleware class attribute is not set. " +
-            "We need a middleware to insert the probe.")
-        end
-        @middleware = middleware
-        @insert_before = insert_before
-      end
-
-      def insert!
-        return true if middleware.instance_variable_get(:"@_timber_inserted") == true
-        # Rails uses a proxy :/
-        middleware.instance_variable_set(:"@_timber_inserted", true)
-        middleware.insert_before insert_before, Middleware
-      end
-    end
-  end
-end

data/lib/timber/probes/server.rb

@@ -1,18 +0,0 @@
-module Timber
-  module Probes
-    class Server < Probe
-      class << self
-        attr_accessor :inserted
-      end
-
-      def insert!
-        return true if self.class.inserted == true
-        context = Contexts::Server.new
-        # Note we don't use a block here, this is because
-        # the context is persistent.
-        CurrentContext.add(context)
-        self.class.inserted = true
-      end
-    end
-  end
-end

data/spec/timber/bootstrap_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Timber::Bootstrap do
-  describe ".bootstrap!" do
-    let(:middleware) { Rack::Builder.new }
-    let(:insert_before) { ::Rails::Rack::Logger }
-
-    def self.it_should_not_bootstrap
-      it "should not bootstrap" do
-        expect(Timber::Probes).to_not receive(:insert!)
-        expect(described_class.bootstrap!(middleware, insert_before)).to be false
-      end
-    end
-
-    def self.it_should_bootstrap
-      it "should bootstrap" do
-        expect(Timber::Probes).to receive(:insert!).once
-        expect(described_class.bootstrap!(middleware, insert_before)).to be true
-      end
-    end
-
-    it_should_bootstrap
-
-    context "disabled" do
-      before(:each) { Timber::Config.enabled = false }
-      after(:each) { Timber::Config.enabled = true }
-
-      it_should_not_bootstrap
-    end
-  end
-end

data/spec/timber/context_snapshot_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe Timber::ContextSnapshot do
-  describe "#initialize" do
-    it "only includes the valid stack" do
-      expect(Timber::CurrentContext).to receive(:valid_stack).once.and_return([])
-      described_class.new
-    end
-  end
-end

data/spec/timber/context_spec.rb

@@ -1,4 +0,0 @@
-require "spec_helper"
-
-describe Timber::Context do
-end

data/spec/timber/contexts/exception_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::Exception do
-  let(:exception) do
-    begin
-      raise StandardError.new("this is a message")
-    rescue Exception => e
-      e
-    end
-  end
-  let(:context) { described_class.new(exception) }
-
-  describe ".as_json" do
-    subject { context.as_json }
-    its([:exception, :backtrace]) { should_not be_nil }
-    its([:exception, :name]) { should eq("StandardError") }
-    its([:exception, :message]) { should eq("this is a message") }
-  end
-
-  describe ".backtrace" do
-    subject { context.backtrace }
-    its(:size) { should eq(5) }
-  end
-
-  describe ".name" do
-    subject { context.name }
-    it { should eq("StandardError") }
-  end
-
-  describe ".message" do
-    subject { context.message }
-    it { should eq("this is a message") }
-  end
-end

data/spec/timber/contexts/organizations/action_controller_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::Organizations::ActionController do
-  around(:each) do |example|
-    class PagesController < ActionController::Base
-      layout nil
-
-      def index
-        render json: {}
-      end
-
-      def method_for_action(action_name)
-        action_name
-      end
-
-      private
-        def current_organization
-          # I want this to execute a query and test logging that query
-          Organization.first
-        end
-    end
-
-    example.run
-
-    Object.send(:remove_const, :PagesController)
-  end
-
-  let(:context) { described_class.new(PagesController.new) }
-
-  describe "#name" do
-    subject { context.name }
-    it { should be_nil }
-
-    context "with an organization" do
-      before(:each) { Organization.create!(name: "Timber") }
-      it { should eq("Timber") }
-
-      context "with an organization context" do
-        around(:each) do |example|
-          Timber::CurrentContext.add(context) do
-            example.run
-          end
-        end
-
-        it { should eq("Timber") }
-      end
-    end
-  end
-end

data/spec/timber/contexts/users/action_controller_spec.rb

@@ -1,65 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::Users::ActionController do
-  around(:each) do |example|
-    class PagesController < ActionController::Base
-      layout nil
-
-      def index
-        render json: {}
-      end
-
-      def method_for_action(action_name)
-        action_name
-      end
-
-      private
-        def current_user
-          # I want this to execute a query and test logging that query
-          @user ||= User.first
-        end
-    end
-
-    example.run
-
-    Object.send(:remove_const, :PagesController)
-
-    Timber::Probes::ActiveSupportLogSubscriber.insert!
-  end
-
-  let(:context) { described_class.new(PagesController.new) }
-
-  describe "#email" do
-    subject { context.email }
-    it { should be_nil }
-
-    context "with a user" do
-      before(:each) { User.create!(email: "a@a.com") }
-      it { should eq("a@a.com") }
-
-      context "with a user context" do
-        around(:each) do |example|
-          Timber::CurrentContext.add(context) do
-            example.run
-          end
-        end
-
-        it { should eq("a@a.com") }
-
-        context "with a debug log level" do
-          around(:each) do |example|
-            old_level = ::Rails.logger.level
-            ::Rails.logger.level = ::Logger::DEBUG
-            example.run
-            ::Rails.logger.level = old_level
-          end
-
-          # If the user object is not cached, it will create an infinite loop.
-          # This is because getting the user executes a query, which in turn creates
-          # logs, with tries to grab the user again, etc.
-          it { should eq("a@a.com") }
-        end
-      end
-    end
-  end
-end

data/spec/timber/current_line_indexes_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe Timber::CurrentLineIndexes do
-  def add_log_line
-    Timber::LogLine.new("test")
-  end
-
-  describe "#log_line_added" do
-    it "only includes the valid stack" do
-      expect(Timber::CurrentContext).to receive(:valid_stack).twice.and_return([])
-      add_log_line
-    end
-
-    context "with a context" do
-      let(:heroku_context) { Timber::Contexts::Servers::HerokuSpecific.new("web.1")}
-
-      around(:each) do |example|
-        Timber::CurrentContext.add(heroku_context) do
-          example.run
-        end
-      end
-
-      context "with a log line" do
-        before(:each) { add_log_line }
-
-        it "sets the context to 0" do
-          expect(described_class.indexes[heroku_context]).to eq(0)
-        end
-
-        context "with an additional log line" do
-          before(:each) { add_log_line }
-
-          it "increments properly" do
-            expect(described_class.indexes[heroku_context]).to eq(1)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/timber/frameworks/rails_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Timber::Frameworks::Rails do
-  # describe described_class::Railtie do
-  #   it "includes the initializer" do
-  #     expect(RailsApp.instance.initializers.collect { |i| i.name }).to include("timber.bootstrap")
-  #   end
-  # end
-end