timber 1.1.14 → 2.0.0

data/lib/timber/log_entry.rb

@@ -3,7 +3,7 @@ module Timber
   # `Logger` and the log device that you set it up with.
   class LogEntry #:nodoc:
     DT_PRECISION = 6.freeze
-    SCHEMA = "https://raw.githubusercontent.com/timberio/log-event-json-schema/1.2.6/schema.json".freeze
+    SCHEMA = "https://raw.githubusercontent.com/timberio/log-event-json-schema/1.2.20/schema.json".freeze
 
     attr_reader :context_snapshot, :event, :level, :message, :progname, :tags, :time, :time_ms
 

data/lib/timber/logger.rb

@@ -16,7 +16,7 @@ module Timber
   # @example Using a Hash
   #   # The :message key is required, the other additional key is your event type and data
   #   # :type is the namespace used in timber for the :data
-  #   logger.info message: "Payment rejected", payment_rejected: {customer_id: customer_id, amount: 100}
+  #   logger.info "Payment rejected", payment_rejected: {customer_id: customer_id, amount: 100}
   #
   # @example Using a Struct (a simple, more structured way, to define events)
   #   PaymentRejectedEvent = Struct.new(:customer_id, :amount, :reason) do
@@ -69,7 +69,7 @@ module Timber
         "INFO" => :info,
         "WARN" => :warn,
         "ERROR" => :error,
-        "FATAL" => :datal,
+        "FATAL" => :fatal,
         "UNKNOWN" => :unknown
       }
 
@@ -81,9 +81,12 @@ module Timber
           tags = extract_active_support_tagged_logging_tags
           time_ms = nil
           if msg.is_a?(Hash)
-            tags << msg.delete(:tag) if msg.key?(:tag)
-            tags += msg.delete(:tags) if msg.key?(:tags)
-            tags.uniq!
+            if msg.key?(:tag) || msg.key?(:tags)
+              tags = tags.clone
+              tags << msg.delete(:tag) if msg.key?(:tag)
+              tags += msg.delete(:tags) if msg.key?(:tags)
+              tags.uniq!
+            end
             time_ms = msg.delete(:time_ms) if msg.key?(:time_ms)
 
             msg = msg[:message] if msg.length == 1
@@ -106,6 +109,16 @@ module Timber
         end
     end
 
+    # For use in development and test environments where you do not want metadata
+    # included in the log lines.
+    class SimpleFormatter < Formatter
+
+      # This method is invoked when a log event occurs
+      def call(severity, timestamp, progname, msg)
+        "#{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+
     # Structures your log messages into Timber's hybrid format, which makes
     # it easy to read while also appending the appropriate metadata.
     #
@@ -153,6 +166,11 @@ module Timber
       end
     end
 
+    class << self
+      def new_from_config
+      end
+    end
+
     # Creates a new Timber::Logger instances. Accepts the same arguments as `::Logger.new`.
     # The only difference is that it default the formatter to {HybridFormatter}. Using
     # a different formatter is easy. For example, if you prefer your logs in JSON.
@@ -175,26 +193,34 @@ module Timber
       end
 
       self.level = environment_level
+
+      @initialized = true
     end
 
     def formatter=(value)
-      if @dev.is_a?(Timber::LogDevices::HTTP)
+      if @initialized && @logdev && @logdev.dev.is_a?(Timber::LogDevices::HTTP) && !value.is_a?(PassThroughFormatter)
         raise ArgumentError.new("The formatter cannot be changed when using the " +
           "Timber::LogDevices::HTTP log device. The PassThroughFormatter must be used for proper " +
           "delivery.")
       end
 
-      if !value.is_a?(Timber::Logger::Formatter)
-        # silently discard this value since rails calls this during initialization :/
-        nil
-      else
-        super
-      end
+      super
     end
 
     # Backwards compatibility with older ActiveSupport::Logger versions
     Logger::Severity.constants.each do |severity|
       class_eval(<<-EOT, __FILE__, __LINE__ + 1)
+        def #{severity.downcase}(*args, &block)
+          progname = args.first
+          options = args.last
+
+          if args.length == 2 and options.is_a?(Hash) && options != {}
+            progname = options.merge(message: progname)
+          end
+
+          add(#{severity}, nil, progname, &block)
+        end
+
         def #{severity.downcase}?                # def debug?
           Logger::#{severity} >= level           #   DEBUG >= level
         end                                      # end

data/lib/timber/overrides.rb

@@ -0,0 +1,9 @@
+require "timber/overrides/lograge"
+require "timber/overrides/rails_server"
+require "timber/overrides/rails_stdout_logging"
+
+module Timber
+  # @private
+  module Overrides
+  end
+end

data/lib/timber/overrides/lograge.rb

@@ -0,0 +1,14 @@
+# Timber and lograge are not compatible installed together. Using lograge
+# with the Timber.io *service* is perfectly fine, but not with the Timber *gem*.
+begin
+  require "lograge"
+
+  module Lograge
+    module_function
+
+    def setup(app)
+      return true
+    end
+  end
+rescue Exception
+end

data/lib/timber/overrides/rails_server.rb

@@ -0,0 +1,10 @@
+begin
+  require "rails/commands/server"
+
+  class ::Rails::Server < ::Rack::Server
+    private
+      def log_to_stdout
+      end
+  end
+rescue Exception
+end

data/lib/timber/util.rb

@@ -1,6 +1,8 @@
 require "timber/util/active_support_log_subscriber"
 require "timber/util/hash"
+require "timber/util/http_event"
 require "timber/util/object"
+require "timber/util/request"
 require "timber/util/struct"
 
 module Timber

data/lib/timber/util/active_support_log_subscriber.rb

@@ -5,7 +5,7 @@ module Timber
       extend self
 
       def find(component, type)
-        ActiveSupport::LogSubscriber.log_subscribers.find do |subscriber|
+        ::ActiveSupport::LogSubscriber.log_subscribers.find do |subscriber|
           subscriber.class == type
         end
       end
@@ -14,16 +14,20 @@ module Timber
         !find(component, type).nil?
       end
 
-      def unsubscribe(component, type)
+      # I don't know why this has to be so complicated, but it is. This code was taken from
+      # lograge :/
+      def unsubscribe!(component, type)
         subscriber = find(component, type)
 
-        if subscriber
-          events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
-          events.each do |event|
-            ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
-              if listener.instance_variable_get('@delegate') == subscriber
-                ActiveSupport::Notifications.unsubscribe listener
-              end
+        if !subscriber
+          raise "We could not find a log subscriber for #{component.inspect} of type #{type.inspect}"
+        end
+
+        events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+        events.each do |event|
+          ::ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
+            if listener.instance_variable_get('@delegate') == subscriber
+              ::ActiveSupport::Notifications.unsubscribe listener
             end
           end
         end

data/lib/timber/util/http_event.rb

@@ -0,0 +1,54 @@
+module Timber
+  module Util
+    module HTTPEvent
+      BODY_LIMIT = 5_000.freeze
+      QUERY_STRING_LIMIT = 5_000.freeze
+
+      extend self
+
+      def full_path(path, query_string)
+        if query_string
+          "#{path}?#{query_string}"
+        else
+          path
+        end
+      end
+
+      def normalize_body(content_type, body)
+        if Config.instance.capture_http_body_content_types.include?(content_type)
+          if body.respond_to?(:body)
+            body = body.body.to_s
+          end
+
+          body[0..(BODY_LIMIT - 1)]
+        else
+          # Drop the body if it is not a format we want to capture.
+          # This gives users more control to avoid loggin files, etc.
+          nil
+        end
+      end
+
+      def normalize_headers(headers)
+        if headers.is_a?(::Hash)
+          headers.each_with_object({}) do |(k, v), h|
+            h[k.to_s.downcase] = v
+          end
+        else
+          headers
+        end
+      end
+
+      def normalize_method(method)
+        method.is_a?(::String) ? method.upcase : method
+      end
+
+      def normalize_query_string(query_string)
+        if !query_string.nil?
+          query_string = query_string.to_s
+        end
+
+        query_string[0..(QUERY_STRING_LIMIT - 1)]
+      end
+    end
+  end
+end

data/lib/timber/util/request.rb

@@ -0,0 +1,44 @@
+begin
+  require "rack"
+rescue LoadError
+end
+
+if defined?(::Rack::Request)
+  module Timber
+    module Util
+      class Request < ::Rack::Request
+        def body_content
+          content = body.read
+          body.rewind
+          content
+        end
+
+        def headers
+          @headers ||= ::Hash[*@env.select {|k,v| k.start_with? 'HTTP_'}
+            .collect {|k,v| [k.sub(/^HTTP_/, ''), v]}
+            .collect {|k,v| [k.split('_').collect(&:capitalize).join('-'), v]}
+            .sort
+            .flatten]
+        end
+
+        def ip
+          @ip ||= if @env["action_dispatch.remote_ip"]
+            @env["action_dispatch.remote_ip"].to_s || super
+          else
+            super
+          end
+        end
+
+        def referer
+          # Rails 3.X returns "/" for some reason
+          @referer ||= super == "/" ? nil : super
+        end
+
+        def request_id
+          @request_id ||= @env["action_dispatch.request_id"] || @env["X-Request-ID"] ||
+            @env["X-Request-Id"]
+        end
+      end
+    end
+  end
+end

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "1.1.14"
+  VERSION = "2.0.0"
 end

data/spec/README.md

@@ -1,23 +1,19 @@
 # Testing
 
-Testing Timber uses [`appraisal`](https://github.com/thoughtbot/appraisal). This allows us to
-test across multiple versions and combinations of libraries.
-
 To get started:
 
 ```shell
 bundle install
-bundle exec appraisal install
 ```
 
-To see all appraisal commands:
+Be sure to install specific Gemfile dependencies:
 
-```shell
-appraisal --help
+```
+BUNDLE_GEMFILE=gemfiles/rails-4.2.gemfile bundle install
 ```
 
-You can run tests with:
+You can run tests like this:
 
 ```shell
-appraisal rails-3.2.X rspec
+BUNDLE_GEMFILE=gemfiles/rails-4.2.gemfile bundle exec rspec
 ```

data/spec/spec_helper.rb

@@ -3,23 +3,20 @@ require 'rubygems'
 require 'bundler/setup'
 
 # Testing
-require 'pry'
 require 'rspec'
 require 'rspec/its'
 require 'rspec/mocks'
 
 # Support files, order is relevant
-require File.join(File.dirname(__FILE__), 'support', 'coveralls')
 require File.join(File.dirname(__FILE__), 'support', 'socket_hostname')
-require File.join(File.dirname(__FILE__), 'support', 'simplecov')
 require File.join(File.dirname(__FILE__), 'support', 'timecop')
 require File.join(File.dirname(__FILE__), 'support', 'webmock')
 require File.join(File.dirname(__FILE__), 'support', 'timber')
 
+# Load framework files after we've setup everything
 if !ENV["RAILS_23"]
   require File.join(File.dirname(__FILE__), 'support', 'rails')
   require File.join(File.dirname(__FILE__), 'support', 'action_controller')
-  require File.join(File.dirname(__FILE__), 'support', 'action_view')
   require File.join(File.dirname(__FILE__), 'support', 'active_record')
 end
 

data/spec/support/action_controller.rb

@@ -1,4 +1,8 @@
-require "action_controller"
+begin
+  require "action_controller"
+rescue LoadError
+end
 
-ActionController::Base.prepend_view_path("#{File.dirname(__FILE__)}/rails/templates")
-ActionController::Base.logger = Rails.logger
+if defined?(::ActionController::Base)
+  ::ActionController::Base.prepend_view_path("#{File.dirname(__FILE__)}/rails/templates")
+end

data/spec/support/active_record.rb

@@ -1,28 +1,32 @@
-require 'active_record'
+begin
+  require 'active_record'
+rescue LoadError
+end
 
-ActiveRecord::Base.logger = Rails.logger
-ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
-ActiveRecord::Schema.define do
-  self.verbose = false
+if defined?(::ActiveRecord::Base)
+  ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+  ActiveRecord::Schema.define do
+    self.verbose = false
 
-  create_table :organizations, :force => true do |t|
-    t.string :name
+    create_table :organizations, :force => true do |t|
+      t.string :name
 
-    t.timestamps :null => false
-  end
+      t.timestamps :null => false
+    end
 
-  create_table :users, :force => true do |t|
-    t.integer :age
-    t.string :email
-    t.string :first_name
+    create_table :users, :force => true do |t|
+      t.integer :age
+      t.string :email
+      t.string :first_name
 
-    t.timestamps :null => false
-  end
+      t.timestamps :null => false
+    end
 
-end
+  end
 
-class Organization < ::ActiveRecord::Base
-end
+  class Organization < ::ActiveRecord::Base
+  end
 
-class User < ::ActiveRecord::Base
+  class User < ::ActiveRecord::Base
+  end
 end

data/spec/support/rails.rb

@@ -1,37 +1,61 @@
-require "rails"
-
-# Defualt the rails logger to nothing, each test shoould be
-# responsible for setting up the logger
-logger = ::Logger.new(STDOUT) # change to STDOUT to see rails logs
-Rails.logger = logger
-
-class RailsApp < Rails::Application
-  if ::Rails.version =~ /^3\./
-    config.secret_token = '1e05af2b349457936a41427e63450937'
-  else
-    config.secret_key_base = '1e05af2b349457936a41427e63450937'
-  end
-  config.active_support.deprecation = :stderr
-  config.eager_load = false
+begin
+  require "rails"
+rescue LoadError
 end
 
-RailsApp.initialize!
-
-module Support
-  module Rails
-    def dispatch_rails_request(path, additional_env_options = {})
-      application = ::Rails.application
-      env = application.respond_to?(:env_config) ? application.env_config.clone : application.env_defaults.clone
-      env["rack.request.cookie_hash"] = {}.with_indifferent_access
-      env["REMOTE_ADDR"] = "123.456.789.10"
-      env["X-Request-Id"] = "unique-request-id-1234"
-      env["action_dispatch.request_id"] = env["X-Request-Id"]
-      env = env.merge(additional_env_options)
-      ::Rack::MockRequest.new(application).get(path, env)
+if defined?(::Rails)
+  # Defualt the rails logger to nothing, each test shoould be
+  # responsible for setting up the logger
+  logger = Timber::Logger.new(nil) # change to STDOUT to see rails logs
+  Rails.logger = logger
+
+  class RailsApp < Rails::Application
+    if ::Rails.version =~ /^3\./
+      config.secret_token = '1e05af2b349457936a41427e63450937'
+    else
+      config.secret_key_base = '1e05af2b349457936a41427e63450937'
     end
+
+    # This ensures our tests fail, otherwise exceptions get swallowed by ActionDispatch::DebugExceptions
+    config.action_dispatch.show_exceptions = false
+    config.active_support.deprecation = :stderr
+    config.eager_load = false
   end
-end
 
-RSpec.configure do |config|
-  config.include Support::Rails
-end
+  RailsApp.initialize!
+
+  module Support
+    module Rails
+      def dispatch_rails_request(path, additional_env_options = {})
+        application = ::Rails.application
+        env = application.respond_to?(:env_config) ? application.env_config.clone : application.env_defaults.clone
+        env["rack.request.cookie_hash"] = {}.with_indifferent_access
+        env["REMOTE_ADDR"] = "123.456.789.10"
+        env["HTTP_X_REQUEST_ID"] = "unique-request-id-1234"
+        env["action_dispatch.request_id"] = env["HTTP_X_REQUEST_ID"]
+        env = env.merge(additional_env_options)
+        ::Rack::MockRequest.new(application).get(path, env)
+      end
+
+      def with_rails_logger(logger)
+        old_logger = ::Rails.logger
+
+        # We have to set these again because rails set's these after initialization.
+        # Since we've already booted the rails app we need to update them all as we
+        # change the logger.
+        #
+        # You can see here that they use simple class attribute, hence the reason we need
+        # to update all of them: https://github.com/rails/rails/blob/700ec897f97c60016ad748236bf3a49ef15a20de/actionview/lib/action_view/base.rb#L157
+        Timber::Frameworks::Rails.set_logger(logger)
+
+        yield
+
+        ::Rails.logger = old_logger
+      end
+    end
+  end
+
+  RSpec.configure do |config|
+    config.include Support::Rails
+  end
+end