timber 2.6.2 → 3.0.0

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

@@ -1,198 +0,0 @@
-# encoding: utf-8
-
-require "timber/cli/io/ansi"
-require "timber/cli/os_helper"
-
-module Timber
-  class CLI
-    class IO
-      module Messages
-        extend self
-
-        APP_URL = "https://app.timber.io"
-        DOCS_URL = "https://timber.io/docs"
-        OBTAIN_KEY_DOCS_URL = "https://timber.io/docs/app/obtain-api-key/"
-        REPO_URL = "https://github.com/timberio/timber-ruby"
-        SUPPORT_EMAIL = "support@timber.io"
-        TWITTER_HANDLE = "@timberdotio"
-        WEBSITE_URL = "https://timber.io"
-        MAX_LENGTH = 80.freeze
-
-        def application_details(app)
-          message = <<-MESSAGE
-Woot! Your API 🔑  is valid: #{app.name} (#{app.environment}) on #{app.platform_type}
-MESSAGE
-          message.rstrip
-        end
-
-        def edit_app_url(app)
-          "#{APP_URL}"
-        end
-
-        def bad_experience_message
-          message = <<-MESSAGE
-Bummer! That is certainly not the experience we were going for.
-
-Could you tell us why you a bad experience?
-
-(this will be sent directly to the Timber engineering team)
-MESSAGE
-          message.rstrip
-        end
-
-        def git_commands
-          message = <<-MESSAGE
-    #{ANSI.colorize("git add config/initializers/timber.rb", :blue)}
-    #{ANSI.colorize("git commit -am 'Install the timber logger'", :blue)}
-MESSAGE
-          message.rstrip
-        end
-
-        def console_url(app)
-          message = <<-MESSAGE
-Your console URL: https://app.timber.io/organizations/timber/apps/#{app.slug}/console
-MESSAGE
-        end
-
-        def contact
-          message = <<-MESSAGE
-Website:       #{WEBSITE_URL}
-Documentation: #{DOCS_URL}
-Support:       #{SUPPORT_EMAIL}
-MESSAGE
-          message.rstrip
-        end
-
-        def copied_to_clipboard
-          IO::ANSI.colorize("(✓ copied to clipboard)", :green)
-        end
-
-        def http_environment_variables(api_key)
-          command = "export TIMBER_API_KEY=\"#{api_key}\""
-          copied = OSHelper.copy_to_clipboard(command)
-
-          message = <<-MESSAGE
-Great! Add this variable to your environment:
-
-    #{ANSI.colorize(command, :blue)}
-
-MESSAGE
-          message = message.rstrip
-
-          if copied
-            message << "\n    #{copied_to_clipboard}"
-          end
-
-          message
-        end
-
-        def header
-          message = <<-MESSAGE
-🌲 Timber.io Ruby Installer - Great Ruby Logging Made *Easy*
-
- ^  ^  ^   ^      ___I_      ^  ^   ^  ^  ^   ^  ^
-/|\\/|\\/|\\ /|\\    /\\-_--\\    /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\
-/|\\/|\\/|\\ /|\\   /  \\_-__\\   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\
-/|\\/|\\/|\\ /|\\   |[]| [] |   /|\\/|\\ /|\\/|\\/|\\ /|\\/|\\
-MESSAGE
-          message.rstrip
-        end
-
-        def heroku_install(app)
-          command = "heroku drains:add #{app.heroku_drain_url}"
-          copied = OSHelper.copy_to_clipboard(command)
-
-          message = <<-MESSAGE
-First, let's setup your Heroku drain. Run this command in a separate window:
-
-    #{ANSI.colorize(command, :blue)}
-MESSAGE
-          message = message.rstrip
-
-          if copied
-            message << "\n    #{copied_to_clipboard}"
-          end
-
-          message
-        end
-
-        def no_api_key_provided
-          message = <<-MESSAGE
-Hey there! Welcome to Timber. In order to proceed, you'll need an API key.
-If you already have one, you can run this installer like:
-
-    #{ANSI.colorize("bundle exec timber install my-api-key", :blue)}
-
-#{obtain_key_instructions}
-MESSAGE
-          message.rstrip
-        end
-
-        def obtain_key_instructions
-          message = <<-MESSAGE
-Don't have a key? Head over to:
-
-    #{ANSI.colorize(APP_URL, :blue)}
-
-For a simple guide, checkout out:
-
-    #{ANSI.colorize(OBTAIN_KEY_DOCS_URL, :blue)}
-
-If you're stuck, contact us:
-
-    #{ANSI.colorize(SUPPORT_EMAIL, :blue)}
-MESSAGE
-          message.rstrip
-        end
-
-        def separator
-          "--------------------------------------------------------------------------------"
-        end
-
-        def spinner(iteration)
-          rem = iteration % 3
-          case rem
-          when 0
-            "/"
-          when 1
-            "-"
-          when 2
-            "\\"
-          end
-        end
-
-        def failed
-          "Failed :("
-        end
-
-        def success
-          "✓ Success!"
-        end
-
-        def task_complete(message)
-          remainder = MAX_LENGTH - message.length - success.length
-
-          dots = "." * remainder
-          "\r#{message}#{dots}#{success}"
-        end
-
-        def task_failed(message)
-          remainder = MAX_LENGTH - message.length - failed.length
-
-          dots = "." * remainder
-          "\r#{message}#{dots}#{failed}"
-        end
-
-        def task_start(message)
-          remainder = MAX_LENGTH - message.length - success.length
-
-          "\r#{message}" + ("." * remainder)
-        end
-
-        def we_love_you_too
-          "Thanks! We 💖 you too!"
-        end
-      end
-    end
-  end
-end

data/lib/timber/cli/os_helper.rb

@@ -1,74 +0,0 @@
-module Timber
-  class CLI
-    module OSHelper
-      def self.can_copy_to_clipboard?
-        `which pbcopy` != ""
-      rescue Exception
-        false
-      end
-
-      def self.copy_to_clipboard(input)
-        ::IO.popen('pbcopy', 'w') { |f| f << input }
-        true
-      rescue Exception
-        false
-      end
-
-      def self.git_clean_working_tree?
-        `git diff-index --quiet HEAD -- || echo "untracked";` == ""
-      end
-
-      def self.git_commit_changes
-        begin
-          `git add config/initializers/timber.rb`
-        rescue Exception
-        end
-
-        `git commit -am 'Install the timber logger'`
-        true
-      rescue Exception
-        false
-      end
-
-      def self.git_master?
-        `git rev-parse --abbrev-ref HEAD` == "master"
-      end
-
-      def self.has_git?
-        begin
-          `which git` != ""
-        rescue Exception
-          false
-        end
-      end
-
-      def self.can_open?
-        begin
-          `which #{open_command}` != ""
-        rescue Exception
-          false
-        end
-      end
-
-      # Attemps to open a URL in the user's default browser across
-      # the popular operating systems.
-      def self.open(link)
-        `#{open_command} #{link}`
-        true
-      rescue Exception
-        false
-      end
-
-      private
-        def self.open_command
-          if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-            "start"
-          elsif RbConfig::CONFIG['host_os'] =~ /darwin/
-            "open"
-          elsif RbConfig::CONFIG['host_os'] =~ /linux|bsd/
-            "xdg-open"
-          end
-        end
-    end
-  end
-end

data/lib/timber/config/integrations/rack.rb

@@ -1,74 +0,0 @@
-module Timber
-  class Config
-    module Integrations
-      # Convenience module for accessing the various `Timber::Integrations::Rack::*` classes
-      # through the {Timber::Config} object. Timber couples configuration with the class
-      # responsibls for implementing it. This provides for a tighter design, but also
-      # requires the user to understand and access the various classes. This module aims
-      # to provide a simple ruby-like configuration interface for internal Timber classes.
-      #
-      # For example:
-      #
-      #     config = Timber::Config.instance
-      #     config.integrations.rack.http_events.enabled = false
-      module Rack
-        extend self
-
-        # Convenience method for accessing the {Timber::Integrations::Rack::ErrorEvent}
-        # middleware class specific configuration. See {Timber::Integrations::Rack::ExceptionEvent}
-        # for a list of methods available.
-        #
-        # @example
-        #   config = Timber::Config.instance
-        #   config.integrations.rack.error_event.enabled = false
-        def error_event
-          Timber::Integrations::Rack::ErrorEvent
-        end
-
-        # Convenience method for accessing the {Timber::Integrations::Rack::HTTPContext}
-        # middleware class specific configuration. See {Timber::Integrations::Rack::HTTPContext}
-        # for a list of methods available.
-        #
-        # @example
-        #   config = Timber::Config.instance
-        #   config.integrations.rack.http_context.enabled = false
-        def http_context
-          Timber::Integrations::Rack::HTTPContext
-        end
-
-        # Convenience method for accessing the {Timber::Integrations::Rack::HTTPEvents}
-        # middleware class specific configuration. See {Timber::Integrations::Rack::HTTPEvents}
-        # for a list of methods available.
-        #
-        # @example
-        #   config = Timber::Config.instance
-        #   config.integrations.rack.http_events.enabled = false
-        def http_events
-          Timber::Integrations::Rack::HTTPEvents
-        end
-
-        # Convenience method for accessing the {Timber::Integrations::Rack::SessionContext}
-        # middleware class specific configuration. See {Timber::Integrations::Rack::SessionContext}
-        # for a list of methods available.
-        #
-        # @example
-        #   config = Timber::Config.instance
-        #   config.integrations.rack.session_context.enabled = false
-        def session_context
-          Timber::Integrations::Rack::SessionContext
-        end
-
-        # Convenience method for accessing the {Timber::Integrations::Rack::UserContext}
-        # middleware class specific configuration. See {Timber::Integrations::Rack::UserContext}
-        # for a list of methods available.
-        #
-        # @example
-        #   config = Timber::Config.instance
-        #   config.integrations.rack.user_context.enabled = false
-        def user_context
-          Timber::Integrations::Rack::UserContext
-        end
-      end
-    end
-  end
-end

data/lib/timber/contexts/custom.rb

@@ -1,44 +0,0 @@
-require "timber/context"
-require "timber/util"
-
-module Timber
-  module Contexts
-    # Custom contexts allow you to add application specific context not covered elsewhere.
-    # Any data added this way will be included in your logs. A good example is worker job
-    # IDs. When processing a job you might add the job ID to the context, allowing you to
-    # view *all* logs generated while processing that job, not just the logs that contain
-    # the ID.
-    #
-    # Note in the example below all custom contexts must contain a root key. This is to
-    # ensure attribute names and types never clash across your contexts. It gives you
-    # much cleaner pallete to organize your data on.
-    #
-    # @example Adding a custom context
-    #   logger.with_context(build: {version: "1.0.0"}) do
-    #     # anything logged here will have the custom context above
-    #     # when this block exits the context will no longer be included
-    #   end
-    class Custom < Context
-      @keyspace = :custom
-
-      attr_reader :type, :data
-
-      def initialize(attributes)
-        normalizer = Util::AttributeNormalizer.new(attributes)
-        @type = normalizer.fetch!(:type, :symbol)
-        @data = normalizer.fetch!(:data, :hash)
-      end
-
-      # Builds a hash representation containing simple objects, suitable for serialization (JSON).
-      def to_hash
-        @to_hash ||= Util::NonNilHashBuilder.build do |h|
-          h.add(type, data)
-        end
-      end
-
-      def as_json(options = {})
-        to_hash
-      end
-    end
-  end
-end

data/lib/timber/contexts/organization.rb

@@ -1,48 +0,0 @@
-require "timber/context"
-require "timber/util"
-
-module Timber
-  module Contexts
-    # The organization context tracks the organization of the currently
-    # authenticated user.
-    #
-    # You will want to add this context at the time you determine
-    # the organization a user belongs to, typically in the authentication
-    # flow.
-    #
-    # Example:
-    #
-    #   organization_context = Timber::Contexts::Organization.new(id: "abc1234", name: "Timber Inc")
-    #   logger.with_context(organization_context) do
-    #     # Logging will automatically include this context
-    #     logger.info("This is a log message")
-    #   end
-    #
-    class Organization < Context
-      ID_MAX_BYTES = 256.freeze
-      NAME_MAX_BYTES = 256.freeze
-
-      @keyspace = :organization
-
-      attr_reader :id, :name
-
-      def initialize(attributes)
-        normalizer = Util::AttributeNormalizer.new(attributes)
-        @id = normalizer.fetch(:id, :string, :limit => ID_MAX_BYTES)
-        @name = normalizer.fetch(:name, :string, :limit => NAME_MAX_BYTES)
-      end
-
-      # Builds a hash representation containing simple objects, suitable for serialization (JSON).
-      def to_hash
-        @to_hash ||= Util::NonNilHashBuilder.build do |h|
-          h.add(:id, id)
-          h.add(:name, name)
-        end
-      end
-
-      def as_json(_options = {})
-        to_hash
-      end
-    end
-  end
-end

data/lib/timber/events/custom.rb

@@ -1,53 +0,0 @@
-require "timber/event"
-require "timber/util"
-
-module Timber
-  module Events
-    # Allows for custom events that aren't covered elsewhere.
-    #
-    # Custom events can be used to encode information about events that are central
-    # to your line of business like receiving credit card payments, saving a draft of a post,
-    # or changing a user's password.
-    #
-    # For examples of logging custom events see {Logger}.
-    class Custom < Timber::Event
-      attr_reader :type, :message, :data
-
-      # Instantiates a new custom event that can be logged. See {Logger} for examples
-      # on logging custom events.
-      #
-      # @param [Hash] attributes the options to create a custom event with.
-      # @option attributes [Symbol] :type *required* The custom event type. This should be in
-      #   snake case. Example: `:my_custom_event`.
-      # @option attributes [String] :message *required* The message to be logged.
-      # @option attributes [Hash] :data A hash of JSON encodable data to be stored with the
-      #   log line.
-      def initialize(attributes)
-        normalizer = Util::AttributeNormalizer.new(attributes)
-        @type = normalizer.fetch!(:type, :symbol)
-        @message = normalizer.fetch!(:message, :string)
-
-        data = normalizer.fetch(:data, :hash, default: {})
-
-        if !data.nil? && data[:time_ms].is_a?(Time)
-          data[:time_ms] = Timer.duration_ms(data[:time_ms])
-          @message << " in #{data[:time_ms]}ms"
-        end
-
-        @data = data
-      end
-
-      def to_hash
-        @to_hash ||= Util::NonNilHashBuilder.build do |h|
-          h.add(type, data)
-        end
-      end
-      alias to_h to_hash
-
-      # Builds a hash representation containing simple objects, suitable for serialization (JSON).
-      def as_json(_options = {})
-        {:custom => to_hash}
-      end
-    end
-  end
-end