timber 2.0.24 → 2.1.0.rc1

data/lib/timber/cli/installers.rb

@@ -0,0 +1,37 @@
+require "timber/cli/api"
+require "timber/cli/installers/root"
+require "timber/cli/io/messages"
+require "timber/cli/os_helper"
+
+module Timber
+  class CLI
+    module Installers
+      def self.run(api_key, io)
+        io.puts IO::Messages.header, :green
+        io.puts IO::Messages.separator, :green
+        io.puts IO::Messages.contact, :green
+        io.puts IO::Messages.separator, :green
+        io.puts ""
+
+        if !api_key
+          io.puts IO::Messages.no_api_key_provided
+
+          case io.ask_yes_no("Open the Timber app in your brower now?")
+          when :yes
+            OSHelper.open(IO::Messages::APP_URL)
+          end
+
+        else
+          api = API.new(api_key)
+          api.event(:started)
+
+          io.api = api
+
+          app = api.application!
+
+          Root.new(io, api).run(app)
+        end
+      end
+    end
+  end
+end

data/lib/timber/cli/installers/other.rb

@@ -0,0 +1,47 @@
+require "timber/cli/installer"
+require "timber/cli/io/messages"
+
+module Timber
+  class CLI
+    module Installers
+      class Other < Installer
+        def run(app)
+          puts ""
+          puts IO::Messages.separator
+          puts ""
+
+          if app.heroku?
+            install_stdout
+          else
+            api_key_storage_preference = get_api_key_storage_preference
+            api_key_code = get_api_key_code(api_key_storage_type)
+
+            install_http(api_key_code)
+          end
+        end
+
+        private
+          def install_stdout
+            puts ""
+            puts IO::Messages.separator
+            puts ""
+            puts "To integrate Timber, we need to instantiate the logger. Your global"
+            puts "logger should be set to something like this:"
+            puts ""
+            puts colorize("    LOGGER = Timber::Logger.new(STDOUT)", :blue)
+          end
+
+          def install_http(api_key_code)
+            puts ""
+            puts IO::Messages.separator
+            puts ""
+            puts "To integrate Timber, we need to instantiate the logger. Your global"
+            puts "logger should be set to something like this:"
+            puts ""
+            puts colorize("    log_device = Timber::LogDevices::HTTP.new(#{api_key_code})", :blue)
+            puts colorize("    LOGGER = Timber::Logger.new(log_device)", :blue)
+          end
+      end
+    end
+  end
+end

data/lib/timber/cli/installers/rails.rb

@@ -0,0 +1,255 @@
+begin
+  require "lograge"
+rescue Exception
+end
+
+require "timber/cli/config_file"
+require "timber/cli/file_helper"
+require "timber/cli/installer"
+require "timber/cli/io/messages"
+
+module Timber
+  class CLI
+    module Installers
+      class Rails < Installer
+        # Runs the installer.
+        def run(app)
+          # Ask all of the questions up front. This allows us to to apply the
+          # changes as a neat task list when done.
+          development_preference = get_development_preference
+          api_key_storage_preference = get_api_key_storage_preference
+          should_logrageify = logrageify?
+
+          io.puts ""
+          io.puts IO::Messages.separator
+          io.puts ""
+
+          # Create the initializer
+          initializer
+
+          if should_logrageify
+            logrageify!
+          end
+
+          environment_file_paths.each do |environment_file_path|
+            environment = File.split(environment_file_path).last.gsub(/\.rb$/, "").to_sym
+
+            case environment
+            when :development
+              setup_development_environment(environment_file_path, development_preference)
+            when :test
+              setup_test_environment(environment_file_path)
+            else
+              setup_other_environment(app, environment_file_path, api_key_storage_preference)
+            end
+          end
+
+          true
+        end
+
+        private
+          def logrageify?
+            if defined?(::Lograge)
+              io.puts ""
+              io.puts IO::Messages.separator
+              io.puts ""
+              io.puts "We noticed you have lograge installed. Would you like to configure "
+              io.puts "Timber to function similarly?"
+              io.puts "(This silences template renders, sql queries, and controller calls."
+              io.puts "You can always do this later in config/initialzers/timber.rb)"
+              io.puts ""
+              io.puts "y) Yes, configure Timber like lograge", :blue
+              io.puts "n) No, use the Rails logging defaults", :blue
+              io.puts ""
+
+              case io.ask_yes_no("Enter your choice:", event_prompt: "Logrageify?")
+              when :yes
+                true
+              when :no
+                false
+              end
+            else
+              false
+            end
+          end
+
+          def logrageify!
+            task_message = "Logrageifying in #{initializer.path}"
+            io.task(task_message) do
+              initializer.logrageify!
+            end
+            true
+          end
+
+          # Determines the development preference
+          def get_development_preference
+            io.puts ""
+            io.puts IO::Messages.separator
+            io.puts ""
+            io.puts "Would you like to temporarily send development logs to Timber?"
+            io.puts "(Logs will still go to STDOUT, but this provides an easy way to kick the "
+            io.puts "tires. Once you're done testing, you can disable this in "
+            io.puts "#{IO::ANSI.colorize("config/environments/development.rb", :yellow)})"
+            io.puts ""
+            io.puts "y) Yes, send development logs to Timber", :blue
+            io.puts "n) No, just print development logs to STDOUT", :blue
+            io.puts ""
+
+            case io.ask_yes_no("Enter your choice:", event_prompt: "Send dev logs to Timber?")
+            when :yes
+              :send
+            when :no
+              :dont_send
+            end
+          end
+
+          def initializer
+            @initializer ||= begin
+              initializer_path = File.join("config", "initializers", "timber.rb")
+              task_message = "Creating #{initializer_path}"
+              io.task(task_message) { ConfigFile.new(initializer_path) }
+            end
+          end
+
+          # Wraps the logger in TaggedLogging if it is available. Older versions of Rails
+          # do not include this constant.
+          def config_set_logger_code
+            @config_set_logger_code ||= defined?(::ActiveSupport::TaggedLogging) ?
+              "ActiveSupport::TaggedLogging.new(logger)" : "logger"
+          end
+
+          # Traverses the config/environments directory and returns an array of
+          # symbols representing the various environments.
+          def environment_file_paths
+            path = File.join("config", "environments", "*.rb")
+            Dir[path]
+          end
+
+          def setup_development_environment(environment_file_path, development_preference)
+            if already_configured?(environment_file_path)
+              message = "Installing the Timber::Logger in #{environment_file_path}"
+              io.puts IO::Messages.task_complete(message), :green
+              return true
+            end
+
+            case development_preference
+            when :send
+              extra_comment = <<-NOTE
+# Note: When you are done testing, simply instantiate the logger like this:
+#
+#   logger = Timber::Logger.new(STDOUT)
+#
+# Be sure to remove the "log_device =" and "logger =" lines below.
+NOTE
+              extra_comment = extra_comment.rstrip
+              install_http(environment_file_path, :inline, extra_comment: extra_comment)
+            when :dont_send
+              install_stdout(environment_file_path)
+            end
+          end
+
+          def setup_test_environment(environment_file_path)
+            if already_configured?(environment_file_path)
+              message = "Installing the Timber::Logger in #{environment_file_path}"
+              io.puts IO::Messages.task_complete(message), :green
+              return true
+            end
+
+            # Tests should not be logged by default.
+            install_nil(environment_file_path)
+          end
+
+          def setup_other_environment(app, environment_file_path, api_key_storage_preference)
+            if already_configured?(environment_file_path)
+              message = "Installing the Timber::Logger in #{environment_file_path}"
+              io.puts IO::Messages.task_complete(message), :green
+              return true
+            end
+
+            if app.heroku?
+              install_stdout(environment_file_path)
+            else
+              install_http(environment_file_path, api_key_storage_preference)
+            end
+          end
+
+          def install_nil(environment_file_path)
+            logger_code = <<-CODE
+  # Install the Timber.io logger but silence all logs (log to nil). We install the
+  # logger to ensure the Rails.logger object exposes the proper API.
+  logger = Timber::Logger.new(nil)
+  logger.level = config.log_level
+  config.logger = #{config_set_logger_code}
+CODE
+
+            install_logger(environment_file_path, logger_code)
+          end
+
+          # Installs the Timber logger using the HTTP transport strategy in the
+          # specified environment file.
+          def install_http(environment_file_path, api_key_storage_type, options = {})
+            api_key_code = get_api_key_code(api_key_storage_type)
+            extra_comment = options[:extra_comment] ? "\n  #{options[:extra_comment]}" : nil
+
+            logger_code = <<-CODE
+  # Install the Timber.io logger, send logs over HTTP.#{extra_comment}
+  log_device = Timber::LogDevices::HTTP.new(#{api_key_code})
+  logger = Timber::Logger.new(log_device)
+  logger.level = config.log_level
+  config.logger = #{config_set_logger_code}
+CODE
+
+            install_logger(environment_file_path, logger_code)
+          end
+
+          # Installs the Timber logger using the STDOUT transport method in the specified
+          # environment file.
+          def install_stdout(environment_file_path)
+            logger_code = <<-CODE
+  # Install the Timber.io logger, send logs over STDOUT. Actual log delivery
+  # to the Timber service is handled external of this application.
+  logger = Timber::Logger.new(STDOUT)
+  logger.level = config.log_level
+  config.logger = #{config_set_logger_code}
+CODE
+
+            install_logger(environment_file_path, logger_code)
+          end
+
+          # Determines if the environment is already configured.
+          def already_configured?(environment_file_path)
+            environment_file_contents = get_environment_file_contents(environment_file_path)
+            logger_installed?(environment_file_contents)
+          end
+
+          # Convenience method for getting the current environment file contents.
+          def get_environment_file_contents(environment_file_path)
+            FileHelper.read(environment_file_path)
+          end
+
+          # Determines if the Timber logger is already installed in the environment
+          # file contents.
+          def logger_installed?(environment_file_contents)
+            environment_file_contents.include?("Timber::Logger.new")
+          end
+
+          # Installs the Timber logger in the specified environment file with the
+          # provided logger code.
+          def install_logger(environment_file_path, logger_code)
+            current_contents = get_environment_file_contents(environment_file_path)
+
+            task_message = "Installing the Timber::Logger in #{environment_file_path}"
+            io.task(task_message) do
+              if !logger_installed?(current_contents)
+                new_contents = current_contents.sub(/\nend/, "\n\n#{logger_code}\nend")
+                FileHelper.write(environment_file_path, new_contents)
+                api.event(:file_written, path: environment_file_path)
+              end
+            end
+
+            true
+          end
+      end
+    end
+  end
+end

data/lib/timber/cli/installers/root.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+# Attempt to load rails so that we can determine the proper sub-installer to use.
+begin
+  require "rails"
+rescue LoadError
+end
+
+require "timber/cli/api"
+require "timber/cli/installer"
+require "timber/cli/installers/other"
+require "timber/cli/installers/rails"
+require "timber/cli/io/messages"
+require "timber/cli/os_helper"
+require "timber/log_devices/http"
+require "timber/logger"
+
+module Timber
+  class CLI
+    module Installers
+      # The root installer is the primary installer that is instantiated and
+      # run when the installer starts. It is responsible for instantiating
+      # the proper sub installers that install Timber in specific frameworks
+      # and environments.
+      class Root < Installer
+        def run(app)
+          io.puts IO::Messages.application_details(app)
+          io.puts ""
+
+          case io.ask_yes_no("Are the above details correct?", event_prompt: "App details correct?")
+          when :yes
+            install_platform(app)
+            run_sub_installer(app)
+            send_test_messages
+            confirm_log_delivery
+
+            assist_with_git
+
+            api.event(:success)
+
+            collect_feedback
+
+            io.puts ""
+            io.puts IO::Messages.separator
+            io.puts ""
+            io.puts IO::Messages.free_data
+            io.puts ""
+
+            true
+
+          when :no
+            io.puts ""
+            io.puts "Bummer. Head to this URL to update the details:"
+            io.puts ""
+            io.puts "    #{IO::Messages.edit_app_url(app)}", :blue
+            io.puts ""
+            io.puts "exiting..."
+
+            false
+          end
+        end
+
+        private
+          def install_platform(app)
+            if app.heroku?
+              io.puts ""
+              io.puts IO::Messages.separator
+              io.puts ""
+              io.puts IO::Messages.heroku_install(app)
+              io.puts ""
+              io.ask_to_proceed
+            end
+
+            true
+          end
+
+          def run_sub_installer(app)
+            sub_installer = get_sub_installer
+            sub_installer.run(app)
+          end
+
+          def get_sub_installer
+            if defined?(::Rails)
+              Rails.new(io, api)
+            else
+              Other.new(io, api)
+            end
+          end
+
+          def send_test_messages
+            task_message = "Sending test logs"
+            io.task(task_message) do
+              http_device = LogDevices::HTTP.new(api.api_key)
+              logger = Logger.new(http_device)
+              logger.info("Welcome to Timber!")
+              logger.info("This is a test log to ensure the pipes are working")
+              logger.info("Be sure to commit and deploy your app to start seeing real logs")
+              # Close flushes and waits
+              http_device.close
+            end
+          end
+
+          def confirm_log_delivery
+            task_message = "Confirming log delivery"
+
+            io.task(task_message) do
+              api.wait_for_logs do |iteration|
+                io.write IO::Messages.task_start(task_message), :blue
+                io.write IO::Messages.spinner(iteration), :blue
+              end
+            end
+          end
+
+          def assist_with_git
+            io.puts ""
+            io.puts IO::Messages.separator
+            io.puts ""
+            io.puts "Last step! We need to commit these changes via git:"
+            io.puts ""
+            io.puts IO::Messages.git_commands
+            io.puts ""
+
+            if OSHelper.has_git?
+              case io.ask_yes_no("We can run these commands for you. Shall we?", event_prompt: "Run git commands?")
+              when :yes
+                io.puts ""
+
+                task_message = "Committing changes via git"
+                io.write IO::Messages.task_start(task_message)
+
+                committed = OSHelper.git_commit_changes
+
+                if committed
+                  io.puts IO::Messages.task_complete(task_message), :green
+                else
+                  io.puts IO::Messages.task_failed(task_message), :red
+
+                  io.puts ""
+                  io.puts "Bummer, it looks like we couldn't access the git command.", :yellow
+                  io.puts "No problem though, just copy and paste the above commands to", :yellow
+                  io.puts "run them manually.", :yellow
+                end
+              when :no
+                io.puts ""
+                io.puts "No problem. Just copy and paste the above commands to run them manually."
+              end
+            else
+              io.puts ""
+              io.puts "Finally, commit your changes:"
+              io.puts ""
+              io.puts IO::Messages.git_commands
+            end
+
+            io.puts ""
+            io.puts "=> Reminder: git push and deploy 🚀 to see logs in staging/production", :yellow
+          end
+
+          def collect_feedback
+            io.puts ""
+            io.puts IO::Messages.separator
+            io.puts ""
+
+            rating = io.ask("How would rate this install experience? 1 (bad) - 5 (perfect)", ["1", "2", "3", "4", "5"])
+
+            case rating
+            when "4", "5"
+              api.event(:feedback, rating: rating.to_i)
+              io.puts ""
+              io.puts IO::Messages.we_love_you_too
+
+            when "1", "2", "3"
+              io.puts ""
+              io.puts IO::Messages.bad_experience_message
+              io.puts ""
+              io.puts "Type your comments below (enter sends)"
+              io.puts ""
+
+              comments = io.gets
+
+              api.event(:feedback, rating: rating.to_i, comments: comments)
+
+              io.puts ""
+              io.puts "Thank you! We take feedback seriously and will work to improve this."
+            end
+        end
+      end
+    end
+  end
+end