timber 2.6.2 → 3.0.0

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

@@ -1,225 +0,0 @@
-require "timber/cli/installer"
-require "timber/cli/installers/config_file"
-require "timber/cli/io/messages"
-
-module Timber
-  class CLI
-    module Installers
-      class Rails < Installer
-        # Runs the installer.
-        def run(app)
-          install_initializer(app)
-          install_development_environment(app)
-          install_test_environment(app)
-
-          if !app.development? && !app.test?
-            install_app_environment(app)
-          end
-        end
-
-        private
-          def install_initializer(app)
-            initializer_path = File.join("config", "initializers", "timber.rb")
-            installer = ConfigFile.new(io, api)
-            installer.run(app, initializer_path)
-          end
-
-          # Determines the development preference
-          def get_development_preference(app)
-            if app.development?
-              return :send
-            else
-              io.puts ""
-              io.puts IO::Messages.separator
-              io.puts ""
-              io.puts "Would you like to temporarily send development logs to this Timber app?"
-              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 ""
-
-              input = io.ask_yes_no("Enter your choice:", event_prompt: "Send dev logs to Timber?")
-
-              io.puts ""
-              io.puts IO::Messages.separator
-              io.puts ""
-
-              case input
-              when :yes
-                :send
-              when :no
-                :dont_send
-              end
-            end
-          end
-
-          def install_development_environment(app)
-            environment_file_path = get_environment_file_path("development")
-            if environment_file_path
-              if already_installed?(environment_file_path)
-                io.task_complete("Timber already installed #{environment_file_path}")
-                return :already_installed
-              end
-
-              development_preference = get_development_preference(app)
-
-              case development_preference
-              when :send
-                api_key_code = get_api_key_code(:inline)
-
-                logger_code = <<-CODE
-  # Install the Timber.io logger
-  # ----------------------------
-  # Remove the `http_device` to stop sending development logs to Timber.
-  # Be sure to keep the `file_device` or replace it with `STDOUT`.
-  http_device = Timber::LogDevices::HTTP.new(#{api_key_code})
-  file_device = File.open("\#{Rails.root}/log/development.log", "a")
-  file_device.binmode
-  log_devices = [http_device, file_device]
-
-  # Do not modify below this line. It's important to keep the `Timber::Logger`
-  # because it provides an API for logging structured data and capturing context.
-  logger = Timber::Logger.new(*log_devices)
-  logger.level = config.log_level
-  config.logger = #{config_set_logger_code}
-CODE
-
-                install_logger(environment_file_path, logger_code)
-                return :http
-
-              else
-                install_stdout(environment_file_path)
-                return :stdout
-              end
-            end
-          end
-
-          def install_test_environment(app)
-            environment_file_path = get_environment_file_path("test")
-            if environment_file_path
-              if already_installed?(environment_file_path)
-                io.task_complete("Timber already installed #{environment_file_path}")
-                return :already_installed
-              end
-
-              # Tests should not be logged by default.
-              install_nil(environment_file_path)
-              :nil
-            end
-          end
-
-          def install_app_environment(app)
-            environment_file_path = get_environment_file_path(app.environment) || get_environment_file_path("production")
-            if environment_file_path
-              if already_installed?(environment_file_path)
-                io.task_complete("Timber already installed #{environment_file_path}")
-                return :already_installed
-              end
-
-              case get_delivery_strategy(app)
-              when :http
-                api_key_storage_preference = get_api_key_storage_preference
-                install_http(environment_file_path, api_key_storage_preference)
-                :http
-              when :stdout
-                install_stdout(environment_file_path)
-                :stdout
-              end
-            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
-
-          def get_environment_file_path(environment)
-            path = File.join("config", "environments", "#{environment}.rb")
-            file_helper.exists?(path) ? path : nil
-          end
-
-          def install_nil(environment_file_path)
-            logger_code = <<-CODE
-  # Install the Timber.io logger
-  # ----------------------------
-  # `nil` is passed to disable logging. It's important to keep the `Timber::Logger`
-  # because it provides an API for logging structured data and capturing context.
-  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)
-            api_key_code = get_api_key_code(api_key_storage_type)
-
-            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 = #{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 installed.
-          def already_installed?(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)
-            file_helper.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")
-                file_helper.write(environment_file_path, new_contents)
-              end
-            end
-
-            true
-          end
-      end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-# 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 ""
-
-          run_sub_installer(app)
-          send_test_messages
-          confirm_log_delivery
-          api.event(:success)
-          collect_feedback
-          wrap_up(app)
-        end
-
-        private
-          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.debug("Welcome to Timber!")
-              logger.debug("This is a test log to ensure the pipes are working")
-              logger.debug("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 wrap_up(app)
-            io.puts ""
-            io.puts IO::Messages.separator
-            io.puts ""
-            io.puts IO::ANSI.colorize("All done! Commit and deploy 🚀  to see logs in Timber.", :yellow)
-            io.puts IO::ANSI.colorize("You can also test drive Timber by starting your app locally.", :yellow)
-            io.puts ""
-          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) or 'skip':", ["1", "2", "3", "4", "5", "skip"])
-
-            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

data/lib/timber/cli/io.rb

@@ -1,100 +0,0 @@
-require "timber/cli/io/ansi"
-require "timber/cli/io/messages"
-
-module Timber
-  class CLI
-    # This is an abstraction for interfacing with IO devices. By default
-    # it uses the STDOUT and STDIN io devices, but can be passed other devices
-    # upon initialization.
-    class IO
-      attr_reader :io_out, :io_in
-      attr_accessor :api
-
-      def initialize(options = {})
-        @io_out = options[:io_out] || STDOUT
-        @io_in = options[:io_in] || STDIN
-      end
-
-      def ask(prompt, allowed_inputs, options = {}, iteration = 0)
-        event_prompt = options[:event_prompt] || prompt
-        write prompt + " "
-        input = gets.downcase
-
-        if allowed_inputs.include?(input)
-          input
-        else
-          if iteration == 10
-            raise "It appears we're having an issue receiving correct input for:\n\n" \
-              "#{prompt}\n\n" \
-              "We were expecting one of #{allowed_inputs}, but got #{input.inspect}."
-          else
-            puts "Woops! That's not a valid input. Please enter one of #{allowed_inputs.join(", ")}."
-            ask(prompt, allowed_inputs, options, iteration + 1)
-          end
-        end
-      end
-
-      def ask_to_proceed
-        message = "Ready to proceed?"
-        case ask_yes_no(message)
-        when :yes
-          true
-        when :no
-          ask_to_proceed
-        end
-      end
-
-      def ask_yes_no(message, options = {})
-        case ask(message + " (y/n)", ["y", "n"], options)
-        when "y"
-          :yes
-        when "n"
-          :no
-        end
-      end
-
-      def gets
-        value = io_in.gets
-        value ? value.chomp.downcase : ""
-      end
-
-      def puts(message, color = nil)
-        if color
-          message = ANSI.colorize(message, color)
-        end
-
-        io_out.puts(message)
-      end
-
-      def task(message, &block)
-        task_start(message)
-        result = yield
-        task_complete(message)
-        result
-      rescue Exception => e
-        task_failed(message)
-        raise e
-      end
-
-      def task_start(message)
-        write IO::Messages.task_start(message), :blue
-      end
-
-      def task_complete(message)
-        puts IO::Messages.task_complete(message), :green
-      end
-
-      def task_failed(message)
-        puts IO::Messages.task_failed(message), :red
-      end
-
-      def write(message, color = nil)
-        if color
-          message = ANSI.colorize(message, color)
-        end
-
-        io_out.write(message)
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Timber
-  class CLI
-    class IO
-      module ANSI
-        def self.colorize(text, color)
-          return text if Gem.win_platform?
-
-          code =
-            case color
-            when :blue then 34
-            when :red then 31
-            when :green then 32
-            when :yellow then 33
-            else 0
-            end
-
-          "\e[#{code}m#{text}\e[0m"
-        end
-      end
-    end
-  end
-end