timber 2.0.24 → 2.1.0.rc1

data/lib/timber/timer.rb

@@ -0,0 +1,21 @@
+module Timber
+  # This is an ultra-simple abstraction for timing code. This provides a little
+  # more control around how Timber automatically processes "timers".
+  #
+  # @example
+  #   timer = Timber::Timer.start
+  #   # ... code to time
+  #   logger.info("My log message", my_event: {time_ms: timer})
+  module Timer
+    # Abstract for starting a timber. Currently this is simply calling `Time.now`.
+    def self.start
+      Time.now
+    end
+
+    # Get the duration in milliseconds from the object returned in {#start}
+    def self.duration_ms(timer)
+      now = Time.now
+      (now - timer) * 1000.0
+    end
+  end
+end

data/lib/timber/util/hash.rb

@@ -16,7 +16,7 @@ module Timber
             v
           end
 
-          if v != nil && v != "" && v != {} && v != []
+          if v != nil && (!v.respond_to?(:length) || v.length > 0)
             new_hash[k] = v
           end
         end

data/lib/timber/util/http_event.rb

@@ -1,7 +1,9 @@
 module Timber
   module Util
+    # Utility module for dealing with HTTP events {Events::HTTPServerRequest},
+    # {Events::HTTPServerResponse}, {Events::HTTPClientRequest}, {Events::HTTPClientResponse}.
     module HTTPEvent
-      AUTHORIZATION_HEADER = 'authorization'.freeze
+      HEADERS_TO_SANITIZE = ['authorization', 'x-amz-security-token'].freeze
       QUERY_STRING_LIMIT = 5_000.freeze
       STRING_CLASS_NAME = 'String'.freeze
 
@@ -15,14 +17,24 @@ module Timber
         end
       end
 
+      # Normalizes the body. If limit if passed it will truncate the body to that limit.
       def normalize_body(body)
         if body.respond_to?(:body)
           body = body.body.to_s
         end
 
-        body[0..(Config.instance.http_body_limit - 1)]
+        limit = Config.instance.http_body_limit
+        if limit
+          body[0..(limit - 1)]
+        else
+          body
+        end
       end
 
+      # Normalizes headers to:
+      #
+      # 1. Ensure the value is UTF8, this will otherwise throw errors upon capturing.
+      # 2. Sanitize sensitive headers such as `Authorization` or custom headers specified in
       def normalize_headers(headers)
         if headers.is_a?(::Hash)
           h = headers.each_with_object({}) do |(k, v), h|
@@ -46,13 +58,14 @@ module Timber
             end
           end
 
-          keys_to_sanitize = [AUTHORIZATION_HEADER] + (Config.instance.header_filters || [])
+          keys_to_sanitize = HEADERS_TO_SANITIZE + (Config.instance.http_header_filters || [])
           Util::Hash.sanitize(h, keys_to_sanitize)
         else
           headers
         end
       end
 
+      # Normalizes the HTTP method into an uppercase string.
       def normalize_method(method)
         method.is_a?(::String) ? method.upcase : method
       end

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "2.0.24"
+  VERSION = "2.1.0.rc1"
 end

data/spec/support/timber.rb

@@ -1,4 +1,3 @@
 require "timber"
-
-config = Timber::Config.instance
-config.append_metadata = true
+require "timber/cli"
+require "timber/cli/io"

data/spec/timber/cli/installers/rails_spec.rb

@@ -0,0 +1,160 @@
+require "spec_helper"
+
+describe Timber::CLI::Installers::Rails, :rails_23 => true do
+  let(:api_key) { "abcd1234" }
+  let(:app) do
+    attributes = {
+      "api_key" => api_key,
+      "environment" => "development",
+      "framework_type" => "rails",
+      "heroku_drain_url" => "http://drain.heroku.com",
+      "name" => "My Rails App",
+      "platform_type" => "other"
+    }
+    Timber::CLI::API::Application.new(attributes)
+  end
+  let(:api) { Timber::CLI::API.new(api_key) }
+  let(:input) { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:io) { Timber::CLI::IO.new(io_out: output, io_in: input) }
+  let(:installer) { described_class.new(io, api) }
+  let(:initial_config_contents) { "# Timber.io Ruby Configuration - Simple Structured Logging\n#\n#  ^  ^  ^   ^      ___I_      ^  ^   ^  ^  ^   ^  ^\n# /|\\/|\\/|\\ /|\\    /\\-_--\\    /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\\n# /|\\/|\\/|\\ /|\\   /  \\_-__\\   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\\n# /|\\/|\\/|\\ /|\\   |[]| [] |   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\\n# -------------------------------------------------------------------\n# Website:       https://timber.io\n# Documentation: https://timber.io/docs\n# Support:       support@timber.io\n# -------------------------------------------------------------------\n\nconfig = Timber::Config.instance\n\n# Add additional configuration here.\n# For a full list of configuration options and their explanations see:\n# http://www.rubydoc.info/github/timberio/timber-ruby/Timber/Config\n\n" }
+
+  describe ".run" do
+    it "should execute properly" do
+      expect(installer).to receive(:get_development_preference).exactly(1).times.and_return(:send)
+      expect(installer).to receive(:get_api_key_storage_preference).exactly(1).times.and_return(:environment)
+      expect(installer).to receive(:logrageify?).exactly(1).times.and_return(true)
+      expect(installer).to receive(:initializer).exactly(1).times.and_return(true)
+      expect(installer).to receive(:logrageify!).exactly(1).times.and_return(true)
+      expect(installer).to receive(:environment_file_paths).exactly(1).times.and_return(["config/environments/development.rb", "config/environments/production.rb", "config/environments/test.rb"])
+      expect(installer).to receive(:setup_development_environment).with("config/environments/development.rb", :send).and_return(true)
+      expect(installer).to receive(:setup_other_environment).with(app, "config/environments/production.rb", :environment).and_return(true)
+      expect(installer).to receive(:setup_test_environment).with("config/environments/test.rb").and_return(true)
+
+      installer.run(app)
+    end
+  end
+
+  describe ".initializer" do
+    it "should create a config file" do
+      config_file_path = "config/initializers/timber.rb"
+
+      expect(Timber::CLI::FileHelper).to receive(:read_or_create).
+        with(config_file_path, initial_config_contents).
+        and_return(initial_config_contents)
+
+      config_file = installer.send(:initializer)
+      expect(config_file.path).to eq(config_file_path)
+    end
+  end
+
+  describe ".logrageify?" do
+    it "should do nothing if Lograge is not detected" do
+      expect(installer.send(:logrageify?)).to eq(false)
+      expect(output.string).to eq("")
+    end
+
+    context "with a Lograge constant" do
+      around(:each) do |example|
+        Lograge = 1
+        example.run
+        Object.send(:remove_const, :Lograge)
+      end
+
+      it "should prompt for Lograge configuration and return true for y" do
+        input.string = "y\n"
+        expect(installer.send(:logrageify?)).to eq(true)
+        expect(output.string).to eq("\n--------------------------------------------------------------------------------\n\nWe noticed you have lograge installed. Would you like to configure \nTimber to function similarly?\n(This silences template renders, sql queries, and controller calls.\nYou can always do this later in config/initialzers/timber.rb)\n\n\e[34my) Yes, configure Timber like lograge\e[0m\n\e[34mn) No, use the Rails logging defaults\e[0m\n\nEnter your choice: (y/n) ")
+      end
+    end
+  end
+
+  describe ".logrageify!" do
+    it "should set the option in the config file" do
+      config_file_path = "config/initializers/timber.rb"
+
+      expect(Timber::CLI::FileHelper).to receive(:read_or_create).
+        with(config_file_path, initial_config_contents).
+        and_return(initial_config_contents)
+
+      expect(Timber::CLI::FileHelper).to receive(:read).
+        with(config_file_path).
+        and_return(initial_config_contents)
+
+      new_config_contents = "# Timber.io Ruby Configuration - Simple Structured Logging\n#\n#  ^  ^  ^   ^      ___I_      ^  ^   ^  ^  ^   ^  ^\n# /|\\/|\\/|\\ /|\\    /\\-_--\\    /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\\n# /|\\/|\\/|\\ /|\\   /  \\_-__\\   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\\n# /|\\/|\\/|\\ /|\\   |[]| [] |   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\\n# -------------------------------------------------------------------\n# Website:       https://timber.io\n# Documentation: https://timber.io/docs\n# Support:       support@timber.io\n# -------------------------------------------------------------------\n\nconfig = Timber::Config.instance\n\nconfig.logrageify!\n\n# Add additional configuration here.\n# For a full list of configuration options and their explanations see:\n# http://www.rubydoc.info/github/timberio/timber-ruby/Timber/Config\n\n"
+
+      expect(Timber::CLI::FileHelper).to receive(:write).
+        with(config_file_path, new_config_contents).
+        and_return(true)
+
+      expect(installer.send(:logrageify!)).to eq(true)
+    end
+  end
+
+  describe ".setup_development_environment" do
+    it "should setup properly" do
+      env_file_path = "config/environments/development.rb"
+
+      expect(Timber::CLI::FileHelper).to receive(:read).
+        with(env_file_path).
+        exactly(2).times.
+        and_return("\nend")
+
+      logger_code = defined?(ActiveSupport::TaggedLogging) ? "ActiveSupport::TaggedLogging.new(logger)" : "logger"
+      new_contents = "\n\n  # Install the Timber.io logger, send logs over HTTP.\n  # Note: When you are done testing, simply instantiate the logger like this:\n#\n#   logger = Timber::Logger.new(STDOUT)\n#\n# Be sure to remove the \"log_device =\" and \"logger =\" lines below.\n  log_device = Timber::LogDevices::HTTP.new('abcd1234')\n  logger = Timber::Logger.new(log_device)\n  logger.level = config.log_level\n  config.logger = #{logger_code}\n\nend"
+
+      expect(Timber::CLI::FileHelper).to receive(:write).
+        with(env_file_path, new_contents).
+        and_return(true)
+
+      expect(api).to receive(:event).with(:file_written, path: env_file_path)
+
+      expect(installer.send(:setup_development_environment, env_file_path, :send)).to eq(true)
+    end
+  end
+
+  describe ".setup_test_environment" do
+    it "should setup properly" do
+      env_file_path = "config/environments/test.rb"
+
+      expect(Timber::CLI::FileHelper).to receive(:read).
+        with(env_file_path).
+        exactly(2).times.
+        and_return("\nend")
+
+      logger_code = defined?(ActiveSupport::TaggedLogging) ? "ActiveSupport::TaggedLogging.new(logger)" : "logger"
+      new_contents = "\n\n  # Install the Timber.io logger but silence all logs (log to nil). We install the\n  # logger to ensure the Rails.logger object exposes the proper API.\n  logger = Timber::Logger.new(nil)\n  logger.level = config.log_level\n  config.logger = #{logger_code}\n\nend"
+
+      expect(Timber::CLI::FileHelper).to receive(:write).
+        with(env_file_path, new_contents).
+        and_return(true)
+
+      expect(api).to receive(:event).with(:file_written, path: env_file_path)
+
+      expect(installer.send(:setup_test_environment, env_file_path)).to eq(true)
+    end
+  end
+
+  describe ".setup_other_environment" do
+    it "should setup properly" do
+      env_file_path = "config/environments/production.rb"
+
+      expect(Timber::CLI::FileHelper).to receive(:read).
+        with(env_file_path).
+        exactly(2).times.
+        and_return("\nend")
+
+      logger_code = defined?(ActiveSupport::TaggedLogging) ? "ActiveSupport::TaggedLogging.new(logger)" : "logger"
+      new_contents = "\n\n  # Install the Timber.io logger, send logs over HTTP.\n  log_device = Timber::LogDevices::HTTP.new(ENV['TIMBER_API_KEY'])\n  logger = Timber::Logger.new(log_device)\n  logger.level = config.log_level\n  config.logger = #{logger_code}\n\nend"
+
+      expect(Timber::CLI::FileHelper).to receive(:write).
+        with(env_file_path, new_contents).
+        and_return(true)
+
+      expect(api).to receive(:event).with(:file_written, path: env_file_path).exactly(1).times
+
+      expect(installer.send(:setup_other_environment, app, env_file_path, :environment)).to eq(true)
+    end
+  end
+end

data/spec/timber/cli/installers/root_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Timber::CLI::Installers::Root, :rails_23 => true do
+  let(:api_key) { "abcd1234" }
+  let(:app) do
+    attributes = {
+      "api_key" => api_key,
+      "environment" => "development",
+      "framework_type" => "rails",
+      "heroku_drain_url" => "http://drain.heroku.com",
+      "name" => "My Rails App",
+      "platform_type" => "other"
+    }
+    Timber::CLI::API::Application.new(attributes)
+  end
+  let(:api) { Timber::CLI::API.new(api_key) }
+  let(:input) { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:io) { Timber::CLI::IO.new(io_out: output, io_in: input) }
+  let(:installer) { described_class.new(io, api) }
+
+  describe ".run" do
+    it "should run properly" do
+      input.string = "y\n"
+
+      expect(installer).to receive(:install_platform).with(app).exactly(1).times.and_return(true)
+      expect(installer).to receive(:run_sub_installer).with(app).exactly(1).times.and_return(true)
+      expect(installer).to receive(:send_test_messages).exactly(1).times.and_return(true)
+      expect(installer).to receive(:confirm_log_delivery).exactly(1).times.and_return(true)
+      expect(installer).to receive(:assist_with_git).exactly(1).times.and_return(true)
+      expect(api).to receive(:event).with(:success).exactly(1).times
+      expect(installer).to receive(:collect_feedback).exactly(1).times.and_return(true)
+
+      expect(installer.run(app)).to eq(true)
+    end
+  end
+
+  describe ".install_platform" do
+    context "non-heroku" do
+      it "should do nothing" do
+        expect(installer.send(:install_platform, app)).to eq(true)
+        expect(output.string).to eq("")
+      end
+    end
+
+    context "heroku" do
+      before(:each) do
+        app.platform_type = "heroku"
+      end
+
+      it "should prompt for Heroku install" do
+        input.string = "y\n"
+
+        expect(installer.send(:install_platform, app)).to eq(true)
+
+        copy_to_clipboard_message = Timber::CLI::OSHelper.copy_to_clipboard? ? "\n    \e[32m(✓ copied to clipboard)\e[0m" : ""
+        expected_output = "\n--------------------------------------------------------------------------------\n\nFirst, let's setup your Heroku drain. Run this command in a separate window:\n\n    \e[34mheroku drains:add http://drain.heroku.com\e[0m#{copy_to_clipboard_message}\n\nReady to proceed? (y/n) "
+        expect(output.string).to eq(expected_output)
+      end
+    end
+  end
+
+  describe ".get_sub_installer" do
+    context "with Rails" do
+      around(:each) do |example|
+        if defined?(Rails)
+          example.run
+        else
+          Rails = true
+          example.run
+          Object.send(:remove_const, :Rails)
+        end
+      end
+
+      it "should return Rails" do
+        expect(installer.send(:get_sub_installer).class).to eq(Timber::CLI::Installers::Rails)
+      end
+    end
+
+    context "without Rails" do
+      around(:each) do |example|
+        if defined?(Rails)
+          OldRails = Rails
+          Object.send(:remove_const, :Rails)
+          example.run
+          Rails = OldRails
+          Object.send(:remove_const, :OldRails)
+        else
+          example.run
+        end
+      end
+
+      it "should return other" do
+        expect(installer.send(:get_sub_installer).class).to eq(Timber::CLI::Installers::Other)
+      end
+    end
+  end
+end

data/spec/timber/config_spec.rb

@@ -0,0 +1,28 @@
+require "singleton"
+require "spec_helper"
+
+describe Timber::Config, :rails_23 => true do
+  let(:config) { Timber::Config.send(:new) }
+
+  describe ".logrageify!" do
+    it "should logrageify" do
+      expect(Timber::Integrations::ActionController.silence?).to eq(false)
+      expect(Timber::Integrations::ActionView.silence?).to eq(false)
+      expect(Timber::Integrations::ActiveRecord.silence?).to eq(false)
+      expect(Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event?).to eq(false)
+
+      config.logrageify!
+
+      expect(Timber::Integrations::ActionController.silence?).to eq(true)
+      expect(Timber::Integrations::ActionView.silence?).to eq(true)
+      expect(Timber::Integrations::ActiveRecord.silence?).to eq(true)
+      expect(Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event?).to eq(true)
+
+      # Reset
+      Timber::Integrations::ActionController.silence = false
+      Timber::Integrations::ActionView.silence = false
+      Timber::Integrations::ActiveRecord.silence = false
+      Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event = false
+    end
+  end
+end

data/spec/timber/current_context_spec.rb

@@ -1,19 +1,68 @@
 require "spec_helper"
 
 describe Timber::CurrentContext, :rails_23 => true do
+  describe ".initialize" do
+    it "should not set the release context" do
+      context = described_class.send(:new)
+      expect(context.send(:hash)).to eq({})
+    end
+
+    context "with Heroku dyno metadata" do
+      around(:each) do |example|
+        ENV['HEROKU_SLUG_COMMIT'] = "2c3a0b24069af49b3de35b8e8c26765c1dba9ff0"
+        ENV['HEROKU_RELEASE_CREATED_AT'] = "2015-04-02T18:00:42Z"
+        ENV['HEROKU_RELEASE_VERSION'] = "v2.3.1"
+
+        example.run
+
+        ENV.delete('HEROKU_SLUG_COMMIT')
+        ENV.delete('HEROKU_RELEASE_CREATED_AT')
+        ENV.delete('HEROKU_RELEASE_VERSION')
+
+        described_class.reset
+      end
+
+      it "should automatically set the release context" do
+        context = described_class.send(:new)
+        expect(context.send(:hash)).to eq({:release=>{:commit_hash=>"2c3a0b24069af49b3de35b8e8c26765c1dba9ff0", :created_at=>"2015-04-02T18:00:42Z", :version=>"v2.3.1"}})
+      end
+    end
+
+    context "with genric env vars" do
+      around(:each) do |example|
+        ENV['RELEASE_COMMIT'] = "2c3a0b24069af49b3de35b8e8c26765c1dba9ff0"
+        ENV['RELEASE_CREATED_AT'] = "2015-04-02T18:00:42Z"
+        ENV['RELEASE_VERSION'] = "v2.3.1"
+
+        example.run
+
+        ENV.delete('RELEASE_COMMIT')
+        ENV.delete('RELEASE_CREATED_AT')
+        ENV.delete('RELEASE_VERSION')
+
+        described_class.reset
+      end
+
+      it "should automatically set the release context" do
+        context = described_class.send(:new)
+        expect(context.send(:hash)).to eq({:release=>{:commit_hash=>"2c3a0b24069af49b3de35b8e8c26765c1dba9ff0", :created_at=>"2015-04-02T18:00:42Z", :version=>"v2.3.1"}})
+      end
+    end
+  end
+
   describe ".add" do
     after(:each) do
       described_class.reset
     end
 
     it "should add the context" do
-      expect(described_class.hash).to eq({})
+      expect(described_class.instance.send(:hash)).to eq({})
 
       described_class.add({build: {version: "1.0.0"}})
-      expect(described_class.hash).to eq({:custom=>{:build=>{:version=>"1.0.0"}}})
+      expect(described_class.instance.send(:hash)).to eq({:custom=>{:build=>{:version=>"1.0.0"}}})
 
       described_class.add({testing: {key: "value"}})
-      expect(described_class.hash).to eq({:custom=>{:build=>{:version=>"1.0.0"}, :testing=>{:key=>"value"}}})
+      expect(described_class.instance.send(:hash)).to eq({:custom=>{:build=>{:version=>"1.0.0"}, :testing=>{:key=>"value"}}})
     end
   end
 
@@ -21,37 +70,37 @@ describe Timber::CurrentContext, :rails_23 => true do
     it "should remove the context by object" do
       context = {:build=>{:version=>"1.0.0"}}
       described_class.add(context)
-      expect(described_class.hash).to eq({:custom => context})
+      expect(described_class.instance.send(:hash)).to eq({:custom => context})
 
       described_class.remove(context)
-      expect(described_class.hash).to eq({})
+      expect(described_class.instance.send(:hash)).to eq({})
     end
 
     it "should remove context by key" do
       context = {:build=>{:version=>"1.0.0"}}
       described_class.add(context)
-      expect(described_class.hash).to eq({:custom => context})
+      expect(described_class.instance.send(:hash)).to eq({:custom => context})
 
       described_class.remove(:custom)
-      expect(described_class.hash).to eq({})
+      expect(described_class.instance.send(:hash)).to eq({})
     end
   end
 
   describe ".with" do
     it "should merge the context and cleanup on block exit" do
-      expect(described_class.hash).to eq({})
+      expect(described_class.instance.send(:hash)).to eq({})
 
       described_class.with({build: {version: "1.0.0"}}) do
-        expect(described_class.hash).to eq({:custom=>{:build=>{:version=>"1.0.0"}}})
+        expect(described_class.instance.send(:hash)).to eq({:custom=>{:build=>{:version=>"1.0.0"}}})
 
         described_class.with({testing: {key: "value"}}) do
-          expect(described_class.hash).to eq({:custom=>{:build=>{:version=>"1.0.0"}, :testing=>{:key=>"value"}}})
+          expect(described_class.instance.send(:hash)).to eq({:custom=>{:build=>{:version=>"1.0.0"}, :testing=>{:key=>"value"}}})
         end
 
-        expect(described_class.hash).to eq({:custom=>{:build=>{:version=>"1.0.0"}}})
+        expect(described_class.instance.send(:hash)).to eq({:custom=>{:build=>{:version=>"1.0.0"}}})
       end
 
-      expect(described_class.hash).to eq({})
+      expect(described_class.instance.send(:hash)).to eq({})
     end
   end
 end