timberio 1.0.0.beta1 → 1.0.0

data/lib/timber/contexts/http_requests/rack.rb

@@ -1,105 +0,0 @@
-require "timber/contexts/http_requests/rack/params"
-
-module Timber
-  module Contexts
-    module HTTPRequests
-      class Rack < HTTPRequest
-        class Headers
-          include Patterns::ToJSON
-
-          attr_reader :env, :request
-
-          def initialize(env, request)
-            @env = env
-            @request = request
-          end
-
-          def content_type
-            @content_type ||= request.content_type
-          end
-
-          def referrer
-            @referrer ||= request.referrer
-          end
-
-          def remote_addr
-            @remote_addr ||= request.ip
-          end
-
-          def request_id
-            return @request_id if defined?(@request_id)
-            found = env.find do |k,v|
-              # Needs to support:
-              # action_dispatch.request_id
-              # HTTP_X_REQUEST_ID
-              # Request-ID
-              # Request-Id
-              # X-Request-ID
-              # X-Request-Id
-              # etc
-              (k.downcase.include?("request_id") || k.downcase.include?("request-id")) && !v.nil?
-            end
-            @request_id = found && found.last
-          end
-
-          def user_agent
-            @user_agent ||= request.user_agent
-          end
-
-          private
-            def json_payload
-              @json_payload ||= {
-                :content_type => content_type,
-                :referrer => referrer,
-                :remote_addr => remote_addr,
-                :request_id => request_id,
-                :user_agent => user_agent
-              }
-            end
-        end
-
-        attr_reader :env
-
-        def initialize(env)
-          # Initialize should be as fast as possible since it is executed inline.
-          # Hence the lazy methods below.
-          @env = env
-          super()
-        end
-
-        def headers
-          @headers ||= Headers.new(env, request)
-        end
-
-        def host
-          @host ||= request.host
-        end
-
-        def method
-          @method ||= request.request_method.upcase
-        end
-
-        def path
-          @path ||= request.path
-        end
-
-        def port
-          @port ||= request.port
-        end
-
-        def query_params
-          @query_params ||= request.params && Params.new(request.params)
-        end
-
-        def scheme
-          @scheme ||= request.scheme
-        end
-
-        private
-          def request
-            @request ||= ::Rack::Request.new(env)
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/http_response.rb

@@ -1,19 +0,0 @@
-module Timber
-  module Contexts
-    # Generica HTTP response shared across all platforms.
-    class HTTPResponse < Context
-      ROOT_KEY = :http_response.freeze
-      VERSION = 1.freeze
-
-      private
-        def json_payload
-          @json_payload ||= Macros::DeepMerger.merge({
-            # order is relevant for logfmt styling
-            :status => status,
-            :headers => headers.as_json,
-            :time_ms => time_ms
-          }, super).freeze
-        end
-    end
-  end
-end

data/lib/timber/contexts/http_responses/action_controller.rb

@@ -1,76 +0,0 @@
-module Timber
-  module Contexts
-    module HTTPResponses
-      class ActionController < HTTPResponse
-        class Headers
-          include Patterns::ToJSON
-
-          attr_reader :response
-
-          def initialize(response)
-            @response = response
-          end
-
-          def content_length
-            @content_length ||= response.content_length
-          end
-
-          def cache_control
-            @cache_control ||= response.headers['Cache-Control']
-          end
-
-          def content_disposition
-            @content_disposition ||= response.headers['Cache-Disposition']
-          end
-
-          def content_type
-            @content_type ||= response.headers['Content-Type']
-          end
-
-          def location
-            @location ||= response.headers['Location']
-          end
-
-          private
-            def json_payload
-              @json_payload ||= {
-                :content_length => content_length,
-                :cache_control => cache_control,
-                :content_disposition => content_disposition,
-                :content_type => content_type,
-                :location => location
-              }
-            end
-        end
-
-        attr_reader :controller
-        attr_accessor :event
-
-        def initialize(controller)
-          @controller = controller
-        end
-
-        def headers
-          @headers ||= Headers.new(response)
-        end
-
-        def status
-          @status ||= response.status
-        end
-
-        def time_ms
-          @time_ms ||= event.duration
-        end
-
-        def valid?
-          !response.nil? && !event.nil?
-        end
-
-        private
-          def response
-            controller.response
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/logger.rb

@@ -1,33 +0,0 @@
-module Timber
-  module Contexts
-    class Logger < Context
-      ROOT_KEY = :logger.freeze
-      VERSION = 1.freeze
-      LEVEL_MAP = {
-        0 => "debug",
-        1 => "info",
-        2 => "warn",
-        3 => "error",
-        4 => "fatal"
-      }
-      UNKNOWN_LEVEL = "unknown"
-
-      attr_reader :level, :progname
-
-      def initialize(level, progname)
-        @level = LEVEL_MAP[level] || UNKNOWN_LEVEL
-        @progname = progname
-        super()
-      end
-
-      private
-        def json_payload
-          @json_payload ||= Macros::DeepMerger.merge({
-            # order is relevant for logfmt styling
-            :level => level,
-            :progname => progname
-          }, super).freeze
-        end
-    end
-  end
-end

data/lib/timber/contexts/organizations/action_controller.rb

@@ -1,34 +0,0 @@
-module Timber
-  module Contexts
-    module Organizations
-      class ActionController < Organization
-        DEFAULT_METHOD_NAME = :current_organization.freeze
-
-        class << self
-          attr_writer :method_name
-
-          def method_name
-            @method_name ||= DEFAULT_METHOD_NAME
-          end
-        end
-
-        attr_reader :controller
-
-        def initialize(controller)
-          @controller = controller
-          super()
-        end
-
-        private
-          def method_name
-            self.class.method_name
-          end
-
-          def organization
-            return @organization if defined?(@organization)
-            @organization = controller.respond_to?(method_name, true) ? controller.send(method_name) : nil
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/server.rb

@@ -1,21 +0,0 @@
-require "socket"
-
-module Timber
-  module Contexts
-    class Server < Context
-      ROOT_KEY = :server.freeze
-      VERSION = 1.freeze
-
-      def hostname
-        @hostname ||= ::Socket.gethostname
-      end
-
-      private
-        def json_payload
-          @json_payload ||= Macros::DeepMerger.merge({
-            :hostname => hostname
-          }, super).freeze
-        end
-    end
-  end
-end

data/lib/timber/contexts/servers/heroku_specific.rb

@@ -1,48 +0,0 @@
-module Timber
-  module Contexts
-    module Servers
-      # Because this is a sub context we do not extend Server.
-      class HerokuSpecific < Context
-        ROOT_KEY = :heroku.freeze
-        VERSION = 1.freeze
-        DELIMITER = ".".freeze
-
-        class << self
-          def json_shell(&_block)
-            Server.json_shell { super }
-          end
-        end
-
-        attr_reader :dyno
-
-        def initialize(dyno)
-          # Initialize should be as fast as possible since it is executed inline.
-          # Hence the lazy methods below.
-          @dyno = dyno
-          super()
-        end
-
-        def process_type
-          @process_type ||= parts.first
-        end
-
-        def dyno_id
-          @dyno_id ||= parts.last
-        end
-
-        private
-          def parts
-            @parts ||= dyno.split(DELIMITER)
-          end
-
-          def json_payload
-            @json_payload ||= Macros::DeepMerger.merge({
-              # order is relevant for logfmt styling
-              :process_type => process_type,
-              :dyno_id => dyno_id
-            }, super).freeze.freeze
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/sql_queries/active_record.rb

@@ -1,30 +0,0 @@
-module Timber
-  module Contexts
-    module SQLQueries
-      class ActiveRecord < SQLQuery
-        attr_reader :log_subscriber, :event
-
-        def initialize(log_subscriber, event)
-          # Initialize should be as fast as possible since it is executed inline.
-          # Hence the lazy methods below.
-          @log_subscriber = log_subscriber
-          @event = event
-          super()
-        end
-
-        def sql
-          @sql ||= payload[:sql].try(:strip)
-        end
-
-        def time_ms
-          @time_ms ||= event.duration
-        end
-
-        private
-          def payload
-            event.payload
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/sql_queries/active_record_specific/binds.rb

@@ -1,37 +0,0 @@
-module Timber
-  module Contexts
-    module SQLQueries
-      class ActiveRecordSpecific < Context
-        class Binds < DynamicValues
-          attr_reader :log_subscriber, :binds
-
-          def initialize(log_subscriber, binds)
-            # Initialize should be as fast as possible since it is executed inline.
-            # Hence the lazy methods below.
-            @log_subscriber = log_subscriber
-            @binds = binds
-            super()
-          end
-
-          private
-            # Override values_array so that this is done in the background thread
-            def values_array
-              @values_array ||= binds.collect do |bind|
-                name, value = render_bind(bind)
-                {:name => name, :value => value}
-              end
-            end
-
-            def render_bind(bind)
-              if bind.is_a?(Array)
-                # AR 4.2.X
-                log_subscriber.render_bind(*bind)
-              else
-                log_subscriber.render_bind(bind)
-              end
-            end
-        end
-      end
-    end
-  end
-end

data/lib/timber/contexts/sql_queries/active_record_specific.rb

@@ -1,59 +0,0 @@
-require "timber/contexts/sql_queries/active_record_specific/binds"
-
-module Timber
-  module Contexts
-    module SQLQueries
-      # Because this is a sub context we extend Context
-      class ActiveRecordSpecific < Context
-        ROOT_KEY = :active_record.freeze
-        VERSION = 1.freeze
-
-        class << self
-          def json_shell(&_block)
-            SQLQuery.json_shell { super }
-          end
-        end
-
-        attr_reader :log_subscriber, :event
-
-        def initialize(log_subscriber, event)
-          # Initialize should be as fast as possible since it is executed inline.
-          # Hence the lazy methods below.
-          @log_subscriber = log_subscriber
-          @event = event
-          super()
-        end
-
-        def binds
-          @binds ||= payload[:binds] && Binds.new(log_subscriber, payload[:binds])
-        end
-
-        def connection_id
-          @connection_id ||= payload[:connection_id].try(:to_s)
-        end
-
-        def statement_name
-          @statement_name ||= payload[:statement_name]
-        end
-
-        def transaction_id
-          @transaction_id ||= event.transaction_id.try(:to_s)
-        end
-
-        private
-          def json_payload
-            @json_payload ||= Macros::DeepMerger.merge({
-              :binds => binds.as_json,
-              :connection_id => connection_id,
-              :statement_name => statement_name,
-              :transaction_id => transaction_id
-            }, super).freeze
-          end
-
-          def payload
-            event.payload
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/sql_query.rb

@@ -1,18 +0,0 @@
-module Timber
-  module Contexts
-    # Base class for SQLQuery sub types.
-    class SQLQuery < Context
-      ROOT_KEY = :sql_query.freeze
-      VERSION = 1.freeze
-
-      private
-        def json_payload
-          @json_payload ||= Macros::DeepMerger.merge({
-            # order is relevant for logfmt styling
-            :sql => sql,
-            :time_ms => time_ms
-          }, super).freeze
-        end
-    end
-  end
-end

data/lib/timber/contexts/template_render.rb

@@ -1,17 +0,0 @@
-module Timber
-  module Contexts
-    class TemplateRender < Context
-      ROOT_KEY = :template_render.freeze
-      VERSION = 1.freeze
-
-      private
-        def json_payload
-          @json_payload ||= Macros::DeepMerger.merge({
-            # order is relevant for logfmt styling
-            :name => name,
-            :time_ms => time_ms
-          }, super).freeze
-        end
-    end
-  end
-end

data/lib/timber/contexts/template_renders/action_view.rb

@@ -1,29 +0,0 @@
-module Timber
-  module Contexts
-    module TemplateRenders
-      class ActionView < TemplateRender
-        attr_reader :event
-
-        def initialize(event)
-          # Initialize should be as fast as possible since it is executed inline.
-          # Hence the lazy methods below.
-          @event = event
-          super()
-        end
-
-        def name
-          @name ||= payload[:identifier]
-        end
-
-        def time_ms
-          @time_ms ||= event.duration
-        end
-
-        private
-          def payload
-            event.payload
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/template_renders/action_view_specific.rb

@@ -1,51 +0,0 @@
-module Timber
-  module Contexts
-    module TemplateRenders
-      # Because this is a sub type we extend Context
-      class ActionViewSpecific < Context
-        ROOT_KEY = :action_view.freeze
-        VERSION = 1.freeze
-
-        class << self
-          def json_shell(&_block)
-            TemplateRender.json_shell { super }
-          end
-        end
-
-        attr_reader :event
-
-        def initialize(event)
-          # Initialize should be as fast as possible since it is executed inline.
-          # Hence the lazy methods below.
-          @event = event
-          super()
-        end
-
-        def cache_hits
-          @cache_hits ||= payload[:cache_hits]
-        end
-
-        def count
-          @count ||= payload[:count]
-        end
-
-        def layout
-          @layout ||= payload[:layout]
-        end
-
-        private
-          def json_payload
-            @json_payload ||= Macros::DeepMerger.merge({
-              :cache_hits => cache_hits,
-              :count => count,
-              :layout => layout
-            }, super).freeze
-          end
-
-          def payload
-            event.payload
-          end
-      end
-    end
-  end
-end

data/lib/timber/contexts/users/action_controller.rb

@@ -1,34 +0,0 @@
-module Timber
-  module Contexts
-    module Users
-      class ActionController < User
-        DEFAULT_METHOD_NAME = :current_user.freeze
-
-        class << self
-          attr_writer :method_name
-
-          def method_name
-            @method_name ||= DEFAULT_METHOD_NAME
-          end
-        end
-
-        attr_reader :controller
-
-        def initialize(controller)
-          @controller = controller
-          super()
-        end
-
-        private
-          def method_name
-            self.class.method_name
-          end
-
-          def user
-            return @user if defined?(@user)
-            @user = controller.respond_to?(method_name, true) ? controller.send(method_name) : nil
-          end
-      end
-    end
-  end
-end

data/lib/timber/current_line_indexes.rb

@@ -1,35 +0,0 @@
-module Timber
-  # Holds the log line counts on a per context basis in memory.
-  class CurrentLineIndexes
-    THREAD_NAMESPACE = :_timber_current_line_counts.freeze
-
-    include Patterns::DelegatedSingleton
-
-    def context_removed(context)
-      indexes.delete(context)
-    end
-
-    def indexes
-      Thread.current[THREAD_NAMESPACE] ||= {}
-    end
-
-    def log_line_added(_log_line)
-      CurrentContext.valid_stack.each do |context|
-        if indexes.key?(context)
-          indexes[context] += 1
-        else
-          indexes[context] = 0
-        end
-      end
-    end
-
-    def reset!
-      indexes.clear
-    end
-
-    def snapshot
-      # No need to cache, this is blown out for each log line
-      LineIndexesSnapshot.new(self)
-    end
-  end
-end

data/lib/timber/internal_logger.rb

@@ -1,35 +0,0 @@
-require "logger"
-
-module Timber
-  # Allows us to prefix all logs with [Timber] without having to
-  # rely on external dependencies. This is slightly different
-  # in that we don't want to create an entirely new logger or modify
-  # the logger they pass us. We only want to prefix logs in the context
-  # of this library.
-  class InternalLogger < ::Logger
-    class Formatter < ::Logger::Formatter
-      TAG = "[Timber]"
-
-      # This method is invoked when a log event occurs
-      def call(_severity, _timestamp, _progname, msg)
-        "#{TAG} #{String === msg ? msg : msg.inspect}\n"
-      end
-    end
-
-    def initialize(*args)
-      super
-      @formatter = Formatter.new
-    end
-
-    # This is a convenience method for logging exceptions. Also
-    # allows us to build a notify hook for any exception that happen in
-    # the Timber library. This is extremely important for quality control.
-    def exception(exception)
-      if !exception.is_a?(Exception)
-        raise ArgumentError.new("#exception must take an Exception type")
-      end
-      # TODO: notify us that this exception happened
-      error("#{exception.inspect}: #{exception.backtrace.inspect}")
-    end
-  end
-end