timber 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5285d17535de9890e141603c444772904265630
-  data.tar.gz: 5ccb28e7a21bdcaa1d5d71822160114e422e5f7f
+  metadata.gz: 0432ed485c5f9ddbe423ae464cabe9365ac1eefc
+  data.tar.gz: 2051b18db981d2542497cb6b26813ce272625833
 SHA512:
-  metadata.gz: ef8847f90d849dabed1702427574a3864095cf6098801cad33cc45302203bdfdd4ccc11fd0c37c9724342ff29bf2f40c3ae9b98bf8da71d07f1b022f71f4b970
-  data.tar.gz: 8a200733730ff167b57ecbf844bd2aa1ab057bbab66dc3f6d407eec4830877c0b68e9437a1464123fd85bd1f150fdea044d3537cdf679d7414974e45f8d35210
+  metadata.gz: 7e9f7183d5447b599b50cd6ca3e566be9e12179209eb1bc26177a71a61d2238bde6abe806593fc5fa0ca08aa4ad5efebf4414c5a72e9afe9745af3276859da09
+  data.tar.gz: 680b421e9412c3e814cc4d116670d2ae583a019501769bd117347b960850fd656f8cc1eacc6cce26e1f0f92cb78c49ea97b0c74c2f7772ad23ccd6fa01004020

data/README.md

@@ -30,7 +30,7 @@ Into this:
 Sent 200 in 45.2ms @metadata {"dt": "2017-02-02T01:33:21.154345Z", "level": "info", "context": {"user": {"id": 1, "name": "Ben Johnson"}, "http": {"method": "GET", "host": "timber.io", "path": "/path", "request_id": "abcd1234"}}, "event": {"http_server_response": {"status": 200, "time_ms": 45.2}}}
 ```
 
-Allowing you to run queries like:
+Allowing you to run queries in the [Timber console](https://app.timber.io) like:
 
 1. `context.request_id:abcd1234` - View all logs generated for a specific request.
 2. `context.user.id:1` - View logs generated by a specific user.
@@ -52,6 +52,20 @@ Allowing you to run queries like:
 3. In your `shell`, run `bundle exec timber install`
 
 
+## Configuration
+
+All configuration options can be seen in the
+[`Timber::Config docs`](http://www.rubydoc.info/github/timberio/timber-ruby/Timber/Config).
+
+Here's a few popular options:
+
+1. `config.timber.format =`
+  * `:default` - This is the default. It's the original, default, unchanged log messages.
+  * `:lograge` - Works exactly like [lograge](https://github.com/roidrage/lograge), except Timber's
+    additional context and metadata is also appended. Lograge++.
+
+
+
 ## Usage
 
 <details><summary><strong>Basic logging</strong></summary><p>

data/lib/timber/cli/install.rb

@@ -32,7 +32,7 @@ module Timber
           case ask_yes_no("Are the above details correct?")
           when :yes
             if app.heroku?
-              create_initializer(:stdout)
+              update_environment_config("production", :stdout)
 
               puts ""
               puts Messages.separator
@@ -55,7 +55,7 @@ module Timber
 
               case ask("Enter your choice: (1/2) ")
               when "1"
-                create_initializer(:http, :api_key_code => "ENV['TIMBER_API_KEY']")
+                update_environment_config("production", :http, :api_key_code => "ENV['TIMBER_API_KEY']")
 
                 puts ""
                 puts Messages.http_environment_variables(app.api_key)
@@ -65,7 +65,7 @@ module Timber
                 puts ""
 
               when "2"
-                create_initializer(:http, :api_key_code => "'#{app.api_key}'")
+                update_environment_config("production", :http, :api_key_code => "'#{app.api_key}'")
 
               end
 
@@ -107,53 +107,48 @@ module Timber
         end
 
         private
-          def create_initializer(log_device_type, options = {})
+          def update_environment_config(name, log_device_type, options = {})
+            path = File.join("config", "environments", "#{name}.rb")
+
             puts ""
-            write Messages.task_start("Creating config/initializers/timber.rb")
+            task_message = "Configuring Timber in #{path}"
+            write Messages.task_start(task_message)
 
             logger_code = \
               case log_device_type
               when :http
                 api_key_code = options[:api_key_code] || raise(ArgumentError.new("the :api_key_code option is required"))
-                "log_device = Timber::LogDevices::HTTP.new(#{api_key_code})\n" +
-                  "  Timber::Logger.new(log_device)"
+
+                logger_code = defined?(::ActiveSupport::TaggedLogging) ? "ActiveSupport::TaggedLogging.new(logger)" : "logger"
+
+                code = <<-CODE
+  # Install the Timber.io logger, send logs over HTTP
+  log_device = Timber::LogDevices::HTTP.new(#{api_key_code})
+  logger = Timber::Logger.new(log_device)
+  logger.level = config.log_level
+  config.logger = #{logger_code}
+CODE
+                code.rstrip
 
               when :stdout
-                "Timber::Logger.new(STDOUT)"
+                code = <<-CODE
+  # Install the Timber.io logger, send logs to STDOUT
+  logger = Timber::Logger.new(STDOUT)
+  logger.level = config.log_level
+  config.logger = #{logger_code}
+CODE
+                code.rstrip
               end
 
-            body = <<-BODY
-# Timber.io Ruby Library
-#
-#  ^  ^  ^   ^      ___I_      ^  ^   ^  ^  ^   ^  ^
-# /|\\/|\\/|\\ /|\\    /\\-_--\\    /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\
-# /|\\/|\\/|\\ /|\\   /  \\_-__\\   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\
-# /|\\/|\\/|\\ /|\\   |[]| [] |   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\
-#
-# Library:  http://github.com/timberio/timber-ruby
-# Docs:     http://www.rubydoc.info/github/timberio/timber-ruby
-# Support:  support@timber.io
-
-logger = case Rails.env
-when "development"
-  # Write logs to STDOUT in a simple message only format
-  Timber::Logger.new(STDOUT).tap do |logger|
-    logger.formatter = Timber::Logger::SimpleFormatter.new
-  end
-when "production", "staging"
-  #{logger_code}
-end
 
-if logger
-  logger.level = Rails.application.config.log_level
-  Timber::Frameworks::Rails.set_logger(logger)
-end
-BODY
+            current_contents = File.read(path)
 
-            FileUtils.mkdir_p(File.join(Dir.pwd, "config", "initializers"))
-            File.write(File.join(Dir.pwd, "config/initializers/timber.rb"), body)
+            if !current_contents.include?("Timber::Logger.new")
+              new_contents = current_contents.sub(/\nend/, "\n\n#{logger_code}\nend")
+              File.write(path, new_contents)
+            end
 
-            puts colorize(Messages.task_complete("Creating config/initializers/timber.rb"), :green)
+            puts colorize(Messages.task_complete(task_message), :green)
           end
 
           def send_test_messages(api_key)

data/lib/timber/config.rb

@@ -1,34 +1,48 @@
 require "singleton"
 
 module Timber
-  # Interface for settings and reading Timber configuration.
+  # Interface for setting and reading Timber configuration.
   #
-  # You can override any configuration supplied here by simply setting it:
+  # For Rails apps this is installed into `config.timber`. See examples below.
   #
-  #     # Rails
-  #     config.timber.api_key = "my api key"
-  #
-  #     # Everything else
-  #     Timber::Config.instance.api_key = "my api key"
-  #
-  # If a value is not explicity set, the environment is checked for it's associated
-  # environment variable. If that is not set, a reasonable default will be chosen. Each
-  # method documents this.
+  # @example Rails example
+  #   config.timber.append_metadata = false
+  # @example Everything else
+  #   config = Timber::Config.instance
+  #   config.append_metdata = false
   class Config
     class NoLoggerError < StandardError; end
 
+    PRODUCTION_NAME = "production".freeze
+    STAGING_NAME = "staging".freeze
+
     include Singleton
 
-    attr_writer :debug_logger, :http_body_limit, :logger
+    attr_writer :append_metadata, :debug_logger, :http_body_limit, :logger
 
+    # @private
     def initialize
       @http_body_limit = 2000
     end
 
+    # The environment your app is running in. Defaults to `RACK_ENV` and `RAILS_ENV`.
+    #
+    # @example Rails
+    #   config.timber.environment = "staging"
+    # @example Everything else
+    #   Timber::Config.instance.environment = "staging"
+    def environment
+      @environment ||= ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+    end
 
     # Set a debug_logger to view internal Timber library log message.
     # Useful for debugging. Defaults to `nil`. If set, debug messages will be
     # written to this logger.
+    #
+    # @example Rails
+    #   config.timber.debug_logger = ::Logger.new(STDOUT)
+    # @example Everything else
+    #   Timber::Config.instance.debug_logger = ::Logger.new(STDOUT)
     def debug_logger
       @debug_logger
     end
@@ -36,16 +50,54 @@ module Timber
     # Truncates captured HTTP bodies to this specified limit. The default is `2000`.
     # If you want to capture more data, you can raise this to a maximum of `5000`,
     # or lower this to be more efficient with data.
+    #
+    # @example Rails
+    #   config.timber.http_body_limit = 500
+    # @example Everything else
+    #   Timber::Config.instance.http_body_limit = 500
     def http_body_limit
       @http_body_limit
     end
 
-    # This is the logger Timber writes to. It should be set to your global
-    # logger to keep the logging destination consitent. Please see `delegate_logger_to`
-    # to  delegate this call to another method. This is set to `Rails.logger`
-    # for rails.
+    # Should the logger append the Timber metadata. This is automatically turned on
+    # for production and staging environments. Other environments should be set manually.
+    # If set to `true` log messages will look like:
+    #
+    #     log message @metadata {...}
+    #
+    # @example Rails
+    #   config.timber.append_metadata = false
+    # @example Everything else
+    #   Timber::Config.instance.append_metadata = false
+    def append_metadata?
+      if defined?(@append_metadata)
+        return @append_metadata == true
+      end
+
+      production? || staging?
+    end
+
+    # This is the logger Timber writes to. All of the Timber integrations write to
+    # this logger. It should be set to your global logger to keep the logging destination consitent.
+    #
+    # For Rails this is set automatically to `Rails.logger`.
+    #
+    # @example Rails
+    #   Rails.logger = Timber::Logger.new(STDOUT)
+    #   config.timber.logger = Rails.logger
+    # @example Everything else
+    #   Timber::Config.instance.logger = Timber::Logger.new(STDOUT)
     def logger
-      @logger || raise(NoLoggerError.new)
+      @logger || Logger.new(STDOUT)
     end
+
+    private
+      def production?
+        environment == PRODUCTION_NAME
+      end
+
+      def staging?
+        environment == STAGING_NAME
+      end
   end
 end

data/lib/timber/frameworks/rails.rb

@@ -1,53 +1,57 @@
 module Timber
   module Frameworks
+    # Module for Rails specific code, such as the Railtie and any methods that assist
+    # with Rails setup.
     module Rails
       # Installs Timber into your Rails app automatically.
       class Railtie < ::Rails::Railtie
         config.timber = Config.instance
 
-        initializer(:timber_silence_logger_complaints, before: :initialize_logger) do
-          # We set a default logger because Rails tries to write to a file by default.
-          # This causes errors on platforms with a read only file system (Heroku).
-          # See this commit: https://github.com/heroku/rails_stdout_logging/commit/13d092650118bcfeb30f383d3274cee46cbf7b8f
-          # Moreover, the Timber logger gets configured properly later in an initiailizer.
-          # This is a hold over until we reach that file in the initialization process.
-          is_heroku = !ENV['DYNO'].nil?
-          if is_heroku
-            logger = defined?(::ActiveSupport::Logger) ?
-              ::ActiveSupport::Logger.new(STDOUT) : ::Logger.new(STDOUT)
-            ::Rails.logger = config.logger = logger
-          end
-        end
-
         # Initialize Timber immediately after the logger in case anything uses the logger
         # during the initialization process.
-        initializer(:timber, after: :initialize_logger) do
-          # The goals here:
-          # 1. Respect the default log device that rails sets in :initialize_logger
-          # 2. Replace the logger with Timber::Logger so that users get our logger API
-          # 3. Disable metadata so that the logger is essentially transparent until further
-          #    configuration in initializers/timber.rb. This allows them to essentially "turn on"
-          #    timber for production, staging, etc.
-          log_device = ::Rails.logger.instance_variable_get(:@logdev).try(:dev)
-          logger = Logger.new(log_device)
-          logger.formatter = Logger::SimpleFormatter.new
-          logger.level = ::Rails.logger.level
-          ::Rails.logger = config.logger = logger
+        initializer(:timber, group: :all, after: :initialize_logger) do
+          logger = Rails.ensure_timber_logger(::Rails.logger)
+          Rails.set_logger(logger)
 
           Rails.configure_middlewares(config.app_middleware)
           Integrations.integrate!
         end
       end
 
+      # This builds a new Timber::Logger from an existing logger. This allows us to transparentl
+      # switch users onto the Timber::Logger since we support a more useful logging API.
+      def self.ensure_timber_logger(existing_logger)
+        if existing_logger.is_a?(Logger)
+          return existing_logger
+        end
+
+        log_device = existing_logger.instance_variable_get(:@logdev).try(:dev)
+        logger = Logger.new(log_device)
+        logger.level = existing_logger.try(:level) || Logger::DEBUG
+        if defined?(::ActiveSupport::TaggedLogging)
+          logger = ::ActiveSupport::TaggedLogging.new(logger)
+        end
+        logger
+      end
+
+      # Sets the Rails logger. Rails
       def self.set_logger(logger)
         if defined?(::ActiveSupport::TaggedLogging) && !logger.is_a?(::ActiveSupport::TaggedLogging)
           logger = ::ActiveSupport::TaggedLogging.new(logger)
         end
 
         Config.instance.logger = logger
-        ::ActionController::Base.logger = logger
-        ::ActionView::Base.logger = logger if ::ActionView::Base.respond_to?(:logger=)
-        ::ActiveRecord::Base.logger = logger
+
+        # Set the various Rails framework loggers. We *have* to do this because Rails
+        # internally sets these with an ActiveSupport.onload(:active_record) { } callback.
+        # We don't have an opportunity to intercept this since the :initialize_logger
+        # initializer loads these modules. Moreover, earlier version of rails don't do this
+        # at all, hence the defined? checks. Yay for being implicit.
+        ::ActionCable::Server::Base.logger = logger if defined?(::ActionCable::Server::Base)
+        ::ActionController::Base.logger = logger if defined?(::ActionController::Base)
+        ::ActionMailer::Base.logger = logger if defined?(::ActionMailer::Base) && ::ActionMailer::Base.respond_to?(:logger=)
+        ::ActionView::Base.logger = logger if defined?(::ActionView::Base) && ::ActionView::Base.respond_to?(:logger=)
+        ::ActiveRecord::Base.logger = logger if defined?(::ActiveRecord::Base)
         ::Rails.logger = logger
       end
 

data/lib/timber/logger.rb

@@ -119,24 +119,26 @@ module Timber
       end
     end
 
-    # Structures your log messages into Timber's hybrid format, which makes
-    # it easy to read while also appending the appropriate metadata.
+    # Structures your log messages as strings and appends metadata if
+    # `Timber::Config.instance.append_metadata?` is true.
     #
-    #   logger = Timber::Logger.new(STDOUT)
-    #   logger.formatter = Timber::JSONFormatter.new
-    #
-    # Example message:
+    # Example message with metdata:
     #
     #   My log message @metadata {"level":"info","dt":"2016-09-01T07:00:00.000000-05:00"}
     #
-    class HybridFormatter < Formatter
+    class StringFormatter < Formatter
       METADATA_CALLOUT = "@metadata".freeze
 
       def call(severity, time, progname, msg)
         log_entry = build_log_entry(severity, time, progname, msg)
-        metadata = log_entry.to_json(:except => [:message])
-        # use << for concatenation for performance reasons
-        log_entry.message.gsub("\n", "\\n") << " " << METADATA_CALLOUT << " " << metadata << "\n"
+
+        if Config.instance.append_metadata?
+          metadata = log_entry.to_json(:except => [:message])
+          # use << for concatenation for performance reasons
+          log_entry.message.gsub("\n", "\\n") << " " << METADATA_CALLOUT << " " << metadata << "\n"
+        else
+          log_entry.message + "\n"
+        end
       end
     end
 
@@ -190,7 +192,7 @@ module Timber
       if args.size == 1 and args.first.is_a?(LogDevices::HTTP)
         self.formatter = PassThroughFormatter.new
       else
-        self.formatter = HybridFormatter.new
+        self.formatter = StringFormatter.new
       end
 
       self.level = environment_level

data/lib/timber/logger/metadata_methods.rb

@@ -0,0 +1 @@
+metadata_methods.rb

data/lib/timber/overrides.rb

@@ -1,5 +1,4 @@
 require "timber/overrides/lograge"
-require "timber/overrides/rails_server"
 require "timber/overrides/rails_stdout_logging"
 
 module Timber

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "2.0.3"
+  VERSION = "2.0.4"
 end

data/spec/support/timber.rb

@@ -1,3 +1,5 @@
 require "timber"
 
-Timber::Config.instance.debug_logger = ::Logger.new(STDOUT)
+config = Timber::Config.instance
+config.append_metadata = true
+config.debug_logger = ::Logger.new(STDOUT)

data/spec/timber/logger_spec.rb

@@ -10,8 +10,8 @@ describe Timber::Logger, :rails_23 => true do
       Timecop.freeze(time) { example.run }
     end
 
-    context "with the :hybrid format" do
-      before(:each) { logger.formatter = Timber::Logger::HybridFormatter.new }
+    context "with the StringFormatter" do
+      before(:each) { logger.formatter = Timber::Logger::StringFormatter.new }
 
       it "should accept strings" do
         logger.info("this is a test")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timber
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Timber Technologies, Inc.
@@ -198,9 +198,9 @@ files:
 - lib/timber/log_devices/http.rb
 - lib/timber/log_entry.rb
 - lib/timber/logger.rb
+- lib/timber/logger/metadata_methods.rb
 - lib/timber/overrides.rb
 - lib/timber/overrides/lograge.rb
-- lib/timber/overrides/rails_server.rb
 - lib/timber/overrides/rails_stdout_logging.rb
 - lib/timber/util.rb
 - lib/timber/util/active_support_log_subscriber.rb

data/lib/timber/overrides/rails_server.rb

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