timber 2.1.0.rc3 → 2.1.0.rc4

data/lib/timber/cli/io/messages.rb

@@ -92,11 +92,10 @@ MESSAGE
 
         def free_data
           message = <<-MESSAGE
-Because you're awesome, we've credited your account with ✨ 50mb✨. Get more:
+Because you're awesome, we've credited your account with ✨ 100mb✨.
 
-* Get ✨ 250mb✨ for tweeting your experience to #{TWITTER_HANDLE}
-* Get ✨ 100mb✨ for starring our repo: #{REPO_URL}
-* Get ✨ 100mb✨ for following #{TWITTER_HANDLE} on twitter
+* Get ✨ 250mb✨  for starring our repo: #{IO::ANSI.colorize(REPO_URL, :blue)}
+* Get ✨ 250mb✨  for tweeting your experience to #{IO::ANSI.colorize(TWITTER_HANDLE, :blue)}
 MESSAGE
           message.rstrip
         end

data/lib/timber/current_context.rb

@@ -1,5 +1,8 @@
+require "socket"
+
 require "timber/config"
 require "timber/contexts/release"
+require "timber/contexts/system"
 
 module Timber
   # Holds the current context in a thread safe memory storage. This context is
@@ -81,7 +84,7 @@ module Timber
     #   to only neccessary data.
     def add(*objects)
       objects.each do |object|
-        add_to(hash, object)
+        add_to!(hash, object)
       end
       expire_cache!
       self
@@ -142,14 +145,23 @@ module Timber
       # it's hash properly.
       def build_initial_hash
         new_hash = {}
+
+        # Release context
         release_context = Contexts::Release.from_env
         if release_context
-          add_to(new_hash, release_context)
+          add_to!(new_hash, release_context)
         end
+
+        # System context
+        hostname = Socket.gethostname
+        pid = Process.pid
+        system_context = Contexts::System.new(hostname: hostname, pid: pid)
+        add_to!(new_hash, system_context)
+
         new_hash
       end
 
-      def add_to(hash, object)
+      def add_to!(hash, object)
         context = Contexts.build(object) # Normalizes objects into a Timber::Context descendant.
         key = context.keyspace
         json = context.as_json # Convert to json now so that we aren't doing it for every line

data/lib/timber/log_entry.rb

@@ -33,16 +33,6 @@ module Timber
       @message = message.is_a?(String) ? message : message.inspect
       @tags = options[:tags]
       @time_ms = options[:time_ms]
-
-      context_snapshot = {} if context_snapshot.nil?
-
-      # Set the system context for each log entry since processes can be forked
-      # and the process ID could change.
-      hostname = Socket.gethostname
-      pid = Process.pid
-      system_context = Contexts::System.new(hostname: hostname, pid: pid)
-      context_snapshot[system_context.keyspace] = system_context.as_json
-
       @context_snapshot = context_snapshot
       @event = event
     end

data/lib/timber/logger.rb

@@ -92,8 +92,8 @@ module Timber
           elsif logged_obj.is_a?(Hash)
             # Extract the tags
             tags = tags.clone
-            tags << logged_obj.delete(:tag) if logged_obj.key?(:tag)
-            tags += logged_obj.delete(:tags) if logged_obj.key?(:tags)
+            tags.push(logged_obj.delete(:tag)) if logged_obj.key?(:tag)
+            tags.concat(logged_obj.delete(:tags)) if logged_obj.key?(:tags)
             tags.uniq!
 
             # Extract the time_ms
@@ -113,9 +113,13 @@ module Timber
         # Because of all the crazy ways Rails has attempted tags, we need this crazy method.
         def extract_active_support_tagged_logging_tags
           Thread.current[:activesupport_tagged_logging_tags] ||
-            Thread.current["activesupport_tagged_logging_tags:#{object_id}"] ||
+            Thread.current[tagged_logging_object_key_name] ||
             EMPTY_ARRAY
         end
+
+        def tagged_logging_object_key_name
+          @tagged_logging_object_key_name ||= "activesupport_tagged_logging_tags:#{object_id}"
+        end
     end
 
     # For use in development and test environments where you do not want metadata

data/lib/timber/util.rb

@@ -3,7 +3,6 @@ require "timber/util/hash"
 require "timber/util/http_event"
 require "timber/util/object"
 require "timber/util/request"
-require "timber/util/string"
 require "timber/util/struct"
 
 module Timber

data/lib/timber/util/http_event.rb

@@ -33,28 +33,16 @@ module Timber
 
       # Normalizes headers to:
       #
-      # 1. Ensure the value is UTF8, this will otherwise throw errors upon capturing.
+      # 1. Only select values that are UTF8, otherwise they will throw errors when serializing.
       # 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|
-            # Force the header into a valid UTF-8 string, otherwise we will encounter
-            # encoding issues when we serialize this data. Moreoever, if the
-            # data is already valid UTF-8 we don't pay a penalty.
-            #
-            # Note: we compare the class name because...
-            #
-            #   string = 'my string'.force_encoding('ASCII-8BIT')
-            #   string.is_a?(String) => false
-            #   string.class => String
-            #   string.class == String => false
-            #   string.class.name == "String" => true
-            #
-            # ¯\_(ツ)_/¯
-            if v.class.name == STRING_CLASS_NAME
-              h[k] = Timber::Util::String.normalize_to_utf8(v)
-            else
-              h[k] = v
+            if v
+              v = v.to_s
+              if [Encoding::UTF_8, Encoding::US_ASCII].include?(v.encoding)
+                h[k] = v
+              end
             end
           end
 

data/lib/timber/util/request.rb

@@ -8,8 +8,17 @@ if defined?(::Rack::Request)
     module Util
       # @private
       class Request < ::Rack::Request
+        # We store strings as constants since they are reused on a per request basis.
+        # This avoids string allocations.
+        HTTP_HEADER_ORIGINAL_DELIMITER = '_'.freeze
+        HTTP_HEADER_NEW_DELIMITER = '_'.freeze
         HTTP_PREFIX = 'HTTP_'.freeze
 
+        REMOTE_IP_KEY_NAME = 'action_dispatch.remote_ip'.freeze
+        REQUEST_ID_KEY_NAME1 = 'action_dispatch.request_id'.freeze
+        REQUEST_ID_KEY_NAME2 = 'X-Request-ID'.freeze
+        REQUEST_ID_KEY_NAME3 = 'X-Request-Id'.freeze
+
         def body_content
           content = body.read
           body.rewind
@@ -18,19 +27,30 @@ if defined?(::Rack::Request)
 
         # Returns a list of request headers. The rack env contains a lot of data, this function
         # identifies those that were the actual request headers.
+        #
+        # This was extracted from: https://github.com/ruby-grape/grape/blob/91c6c78ae3d3f3ffabaf57ffc4dc35ab7cfc7b5f/lib/grape/request.rb#L30
         def headers
-          @headers ||= ::Hash[
-            *@env.select { |k,v| k.is_a?(String) && k.start_with?(HTTP_PREFIX) }
-              .collect { |k,v| [k.sub(/^#{HTTP_PREFIX}/, ''), v] }
-              .collect { |k,v| [k.split('_').collect(&:capitalize).join('-'), v] }
-              .sort
-              .flatten
-          ]
+          @headers ||= begin
+            headers = {}
+
+            @env.each_pair do |k, v|
+              next unless k.is_a?(String) && k.to_s.start_with?(HTTP_PREFIX)
+
+              k = k[5..-1].
+                split(HTTP_HEADER_ORIGINAL_DELIMITER).
+                each(&:capitalize!).
+                join(HTTP_HEADER_NEW_DELIMITER)
+
+              headers[k] = v
+            end
+
+            headers
+          end
         end
 
         def ip
-          @ip ||= if @env["action_dispatch.remote_ip"]
-            @env["action_dispatch.remote_ip"].to_s || super
+          @ip ||= if @env[REMOTE_IP_KEY_NAME]
+            @env[REMOTE_IP_KEY_NAME].to_s || super
           else
             super
           end
@@ -42,8 +62,9 @@ if defined?(::Rack::Request)
         end
 
         def request_id
-          @request_id ||= @env["action_dispatch.request_id"] || @env["X-Request-ID"] ||
-            @env["X-Request-Id"]
+          @request_id ||= @env[REQUEST_ID_KEY_NAME1] ||
+            @env[REQUEST_ID_KEY_NAME12] ||
+            @env[REQUEST_ID_KEY_NAME3]
         end
       end
     end

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "2.1.0.rc3"
+  VERSION = "2.1.0.rc4"
 end

data/spec/timber/cli/config_file_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Timber::CLI::ConfigFile, :rails_23 => true do
+  let(:path) { "config/initializers/timber.rb" }
+  let(:config_file) { described_class.new(path) }
+  let(:initial_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" }
+  let(:contents_hook) { "# Add additional configuration here." }
+
+  describe ".create!" do
+    it "should create" do
+      expect(Timber::CLI::FileHelper).to receive(:write).with(path, initial_contents).exactly(1).times
+      config_file.create!
+    end
+  end
+
+  describe ".logrageify!" do
+    it "should set the option in the config file" do
+      config_file.logrageify!
+      new_contents = initial_contents.gsub(contents_hook, "config.logrageify!\n\n#{contents_hook}")
+      expect(config_file.send(:content)).to eq(new_contents)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Timber::CLI::Installers::ConfigFile, :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 run properly" do
+      path = "/path/to/file"
+      config_file = Timber::CLI::ConfigFile.new(path)
+
+      expect(Timber::CLI::ConfigFile).to receive(:new).with(path).and_return(config_file)
+      expect(config_file).to receive(:exists?).exactly(1).times.and_return(false)
+      expect(installer).to receive(:logrageify?).exactly(1).times.and_return(true)
+      expect(config_file).to receive(:logrageify!).exactly(1).times
+      expect(config_file).to receive(:create!).exactly(1).times
+
+      installer.run(app, 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
+end

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Timber::CLI::Installers::Other, :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
+    context "heroku" do
+      before(:each) do
+        app.platform_type = "heroku"
+      end
+
+      it "should run properly" do
+        expect(installer).to receive(:install_stdout).exactly(1).times
+        expect(installer).to receive(:ask_to_proceed).exactly(1).times
+
+        installer.run(app)
+      end
+    end
+
+    context "non-heroku" do
+      it "should run properly" do
+        api_key_code = "'#{api_key}'"
+        expect(installer).to receive(:get_api_key_storage_preference).exactly(1).times.and_return(:inline)
+        expect(installer).to receive(:get_api_key_code).with(:inline).exactly(1).times.and_return(api_key_code)
+        expect(installer).to receive(:install_http).with(api_key_code).exactly(1).times
+        expect(installer).to receive(:ask_to_proceed).exactly(1).times
+
+        installer.run(app)
+      end
+    end
+  end
+end

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

@@ -18,143 +18,338 @@ describe Timber::CLI::Installers::Rails, :rails_23 => true do
   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" }
+  let(:logger_code) { defined?(ActiveSupport::TaggedLogging) ? "ActiveSupport::TaggedLogging.new(logger)" : "logger" }
 
   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)
+    context "development" do
+      it "should execute properly" do
+        expect(installer).to receive(:install_initializer).with(app).exactly(1).times
+        expect(installer).to receive(:install_development_environment).with(app).exactly(1).times
+        expect(installer).to receive(:install_test_environment).with(app).exactly(1).times
+        expect(installer).to_not receive(:install_app_environment)
+
+        installer.run(app)
+      end
     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)
+    context "staging" do
+      before(:each) do
+        app.environment = "staging"
+      end
 
-      config_file = installer.send(:initializer)
-      expect(config_file.path).to eq(config_file_path)
-    end
-  end
+      it "should execute properly" do
+        expect(installer).to receive(:install_initializer).with(app).exactly(1).times
+        expect(installer).to receive(:install_development_environment).with(app).exactly(1).times
+        expect(installer).to receive(:install_test_environment).with(app).exactly(1).times
+        expect(installer).to receive(:install_app_environment).with(app).exactly(1).times
 
-  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("")
+        installer.run(app)
+      end
     end
 
-    context "with a Lograge constant" do
-      around(:each) do |example|
-        Lograge = 1
-        example.run
-        Object.send(:remove_const, :Lograge)
+    context "production" do
+      before(:each) do
+        app.environment = "production"
       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) ")
+      it "should execute properly" do
+        expect(installer).to receive(:install_initializer).with(app).exactly(1).times
+        expect(installer).to receive(:install_development_environment).with(app).exactly(1).times
+        expect(installer).to receive(:install_test_environment).with(app).exactly(1).times
+        expect(installer).to receive(:install_app_environment).with(app).exactly(1).times
+
+        installer.run(app)
       end
     end
   end
 
-  describe ".logrageify!" do
-    it "should set the option in the config file" do
+  describe ".install_initializer" do
+    it "should create a config file" do
       config_file_path = "config/initializers/timber.rb"
+      expect_any_instance_of(Timber::CLI::Installers::ConfigFile).to receive(:run).with(app, config_file_path).exactly(1).times
 
-      expect(Timber::CLI::FileHelper).to receive(:read_or_create).
-        with(config_file_path, initial_config_contents).
-        and_return(initial_config_contents)
+      installer.send(:install_initializer, app)
+    end
+  end
 
-      expect(Timber::CLI::FileHelper).to receive(:read).
-        with(config_file_path).
-        and_return(initial_config_contents)
+  describe ".install_development_environment" do
+    let(:env_file_path) { "config/environments/development.rb" }
+
+    context "env file exists" do
+      context "not installed" do
+        context "send logs" do
+          it "should setup properly" do
+            expect(installer).to receive(:get_environment_file_path).
+              with("development").
+              exactly(1).times.
+              and_return(env_file_path)
+
+            expect(installer).to receive(:already_installed?).
+              with(env_file_path).
+              exactly(1).times.
+              and_return(false)
+
+            expect(installer).to receive(:get_development_preference).
+              with(app).
+              exactly(1).times.
+              and_return(:send)
+
+            expected_code = <<-CODE
+  # Install the Timber.io logger
+  send_logs_to_timber = true # <---- set to false to stop sending dev logs to Timber.io
+
+  log_device = send_logs_to_timber ? Timber::LogDevices::HTTP.new('#{app.api_key}') : STDOUT
+  logger = Timber::Logger.new(log_device)
+  logger.level = config.log_level
+  config.logger = #{logger_code}
+CODE
+
+            expect(installer).to receive(:install_logger).
+              with(env_file_path, expected_code).
+              exactly(1).times
+
+            result = installer.send(:install_development_environment, app)
+            expect(result).to eq(:http)
+          end
+        end
+
+        context "dont send" do
+          it "should setup properly" do
+            expect(installer).to receive(:get_environment_file_path).
+              with("development").
+              exactly(1).times.
+              and_return(env_file_path)
+
+            expect(installer).to receive(:already_installed?).
+              with(env_file_path).
+              exactly(1).times.
+              and_return(false)
+
+            expect(installer).to receive(:get_development_preference).
+              with(app).
+              exactly(1).times.
+              and_return(:dont_send)
+
+            expect(installer).to receive(:install_stdout).
+              with(env_file_path).
+              exactly(1).times
+
+            result = installer.send(:install_development_environment, app)
+            expect(result).to eq(:stdout)
+          end
+        end
+      end
 
-      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"
+      context "installed" do
+        it "should skip" do
+          expect(installer).to receive(:get_environment_file_path).
+            with("development").
+            exactly(1).times.
+            and_return(env_file_path)
+
+          expect(installer).to receive(:already_installed?).
+            with(env_file_path).
+            exactly(1).times.
+            and_return(true)
+
+          result = installer.send(:install_development_environment, app)
+          expect(result).to eq(:already_installed)
+        end
+      end
+    end
+  end
 
-      expect(Timber::CLI::FileHelper).to receive(:write).
-        with(config_file_path, new_config_contents).
-        and_return(true)
+  describe ".install_test_environment" do
+    let(:env_file_path) { "config/environments/test.rb" }
+
+    context "env file exists" do
+      context "not installed" do
+        it "should setup properly" do
+          expect(installer).to receive(:get_environment_file_path).
+            with("test").
+            exactly(1).times.
+            and_return(env_file_path)
+
+          expect(installer).to receive(:already_installed?).
+            with(env_file_path).
+            exactly(1).times.
+            and_return(false)
+
+          expect(installer).to receive(:install_nil).
+            with(env_file_path).
+            exactly(1).times
+
+          result = installer.send(:install_test_environment, app)
+          expect(result).to eq(:nil)
+        end
+      end
 
-      expect(installer.send(:logrageify!)).to eq(true)
+      context "installed" do
+        it "should skip" do
+          expect(installer).to receive(:get_environment_file_path).
+            with("test").
+            exactly(1).times.
+            and_return(env_file_path)
+
+          expect(installer).to receive(:already_installed?).
+            with(env_file_path).
+            exactly(1).times.
+            and_return(true)
+
+          result = installer.send(:install_test_environment, app)
+          expect(result).to eq(:already_installed)
+        end
+      end
     end
   end
 
-  describe ".setup_development_environment" do
-    it "should setup properly" do
-      env_file_path = "config/environments/development.rb"
+  describe ".install_app_environment" do
+    context "production" do
+      before(:each) do
+        app.environment = "production"
+      end
 
-      expect(Timber::CLI::FileHelper).to receive(:read).
-        with(env_file_path).
-        exactly(2).times.
-        and_return("\nend")
+      let(:env_file_path) { "config/environments/production.rb" }
+
+      context "env file exists" do
+        context "not installed" do
+          context "http" do
+            it "should setup properly" do
+              expect(installer).to receive(:get_environment_file_path).
+                with("production").
+                exactly(1).times.
+                and_return(env_file_path)
+
+              expect(installer).to receive(:already_installed?).
+                with(env_file_path).
+                exactly(1).times.
+                and_return(false)
+
+              expect(installer).to receive(:get_delivery_strategy).
+                with(app).
+                exactly(1).times.
+                and_return(:http)
+
+              expect(installer).to receive(:get_api_key_storage_preference).
+                exactly(1).times.
+                and_return(:inline)
+
+              expect(installer).to receive(:install_http).
+                with(env_file_path, :inline).
+                exactly(1).times
+
+              result = installer.send(:install_app_environment, app)
+              expect(result).to eq(:http)
+            end
+          end
+
+          context "stdout" do
+            it "should setup properly" do
+              expect(installer).to receive(:get_environment_file_path).
+                with("production").
+                exactly(1).times.
+                and_return(env_file_path)
+
+              expect(installer).to receive(:already_installed?).
+                with(env_file_path).
+                exactly(1).times.
+                and_return(false)
+
+              expect(installer).to receive(:get_delivery_strategy).
+                with(app).
+                exactly(1).times.
+                and_return(:stdout)
+
+              expect(installer).to receive(:install_stdout).
+                with(env_file_path).
+                exactly(1).times
+
+              result = installer.send(:install_app_environment, app)
+              expect(result).to eq(:stdout)
+            end
+          end
+        end
+
+        context "installed" do
+          it "should skip" do
+            expect(installer).to receive(:get_environment_file_path).
+              with("production").
+              exactly(1).times.
+              and_return(env_file_path)
+
+            expect(installer).to receive(:already_installed?).
+              with(env_file_path).
+              exactly(1).times.
+              and_return(true)
+
+            result = installer.send(:install_app_environment, app)
+            expect(result).to eq(:already_installed)
+          end
+        end
+      end
+    end
+  end
 
-      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"
+  describe ".get_environment_file_path" do
+    it "should return the file if it exists" do
+      env_file_path = "config/environments/development.rb"
+      expect(installer.file_helper).to receive(:exists?).with(env_file_path).exactly(1).times.and_return(true)
 
-      expect(Timber::CLI::FileHelper).to receive(:write).
-        with(env_file_path, new_contents).
-        and_return(true)
+      result = installer.send(:get_environment_file_path, "development")
+      expect(result).to eq(env_file_path)
+    end
 
-      expect(api).to receive(:event).with(:file_written, path: env_file_path)
+    it "should return nil if it does not exist" do
+      env_file_path = "config/environments/production.rb"
+      expect(installer.file_helper).to receive(:exists?).with(env_file_path).exactly(1).times.and_return(false)
 
-      expect(installer.send(:setup_development_environment, env_file_path, :send)).to eq(true)
+      result = installer.send(:get_environment_file_path, "production")
+      expect(result).to eq(nil)
     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"
+  describe ".install_nil" do
+    it "should pass the proper code" do
+      env_file_path = "config/environments/development.rb"
 
-      expect(Timber::CLI::FileHelper).to receive(:write).
-        with(env_file_path, new_contents).
-        and_return(true)
+      expected_code = <<-CODE
+  # Install the Timber.io logger, but do not send logs.
+  logger = Timber::Logger.new(nil)
+  logger.level = config.log_level
+  config.logger = #{logger_code}
+CODE
 
-      expect(api).to receive(:event).with(:file_written, path: env_file_path)
+      expect(installer).to receive(:install_logger).
+        with(env_file_path, expected_code).
+        exactly(1).times
 
-      expect(installer.send(:setup_test_environment, env_file_path)).to eq(true)
+      installer.send(:install_nil, env_file_path)
     end
   end
 
-  describe ".setup_other_environment" do
-    it "should setup properly" do
-      env_file_path = "config/environments/production.rb"
+  describe ".install_logger" do
+    context "not installed" do
+      it "should pass the proper code" 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 = "my code"
 
-      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"
+        current_contents = "\nend"
 
-      expect(Timber::CLI::FileHelper).to receive(:write).
-        with(env_file_path, new_contents).
-        and_return(true)
+        expect(installer.file_helper).to receive(:read).
+          with(env_file_path).
+          exactly(1).times.
+          and_return(current_contents)
 
-      expect(api).to receive(:event).with(:file_written, path: env_file_path).exactly(1).times
+        new_contents = "\n\nmy code\nend"
 
-      expect(installer.send(:setup_other_environment, app, env_file_path, :environment)).to eq(true)
+        expect(installer.file_helper).to receive(:write).
+          with(env_file_path, new_contents).
+          exactly(1).times.
+          and_return("\nend")
+
+        installer.send(:install_logger, env_file_path, logger_code)
+      end
     end
   end
 end