timberio 1.0.0.beta1 → 1.0.0

data/lib/timber/current_context.rb

@@ -1,58 +1,43 @@
-require "set"
+require "singleton"
 
 module Timber
-  # Holds the current context in the current thread's memory.
-  # This context gets copied as each log line is written.
+  # Holds the current context in a thread safe memory storage. This context is
+  # appended to every log line. Think of context as join data between your log lines,
+  # allowing you to relate them and filter them appropriately.
   class CurrentContext
-    THREAD_NAMESPACE = :_timber_current_context.freeze
-    STACK_KEYNAME = :stack.freeze
-    PRECISION = 8.freeze
+    include Singleton
 
-    include Patterns::DelegatedSingleton
+    THREAD_NAMESPACE = :_timber_current_context.freeze
 
-    # Adds a context to the current stack.
-    def add(*contexts, &_block)
-      contexts = contexts.compact
-      contexts.each do |context|
-        stack << context
+    class << self
+      # Convenience method for {#with}.
+      #
+      # @example Adding a context
+      #   custom_context = Timber::Contexts::Custom.new(type: :keyspace, data: %{my: "data"})
+      #   Timber::CurrentContext.with(custom_context) do
+      #     # ... anything logged here will have the context ...
+      #   end
+      def with(*args, &block)
+        instance.with(*args, &block)
       end
-      block_given? ? yield : self
-    ensure
-      remove(*contexts) if block_given?
     end
 
-    # Get a specific context type off the stack
-    def get(type)
-      stack.find { |context| context.is_a?(type) }
-    end
-
-    # Removes the contexts from the current stack.
-    def remove(*contexts)
-      # Ensure we clear the cacke when the stack changes
-      contexts.each do |context|
-        CurrentLineIndexes.context_removed(context)
-        stack.delete(context)
-      end
-      self
+    # Adds a context to the current stack.
+    def with(data)
+      key = data.keyspace
+      hash[key] = data
+      yield
+    ensure
+      hash.delete(key)
     end
 
-    # Used to efficiently clone the context
     def snapshot
-      # Cloning the array is efficient and will point to the same objects.
-      Timber::ContextSnapshot.new
-    end
-
-    def valid_stack
-      stack.select(&:valid?)
+      hash.clone
     end
 
     private
-      def stack
-        storage[STACK_KEYNAME] ||= []
-      end
-
-      def storage
+      def hash
         Thread.current[THREAD_NAMESPACE] ||= {}
       end
   end
-end
+end

data/lib/timber/event.rb

@@ -0,0 +1,13 @@
+module Timber
+  # Base class for `Timber::Events::*`
+  # @private
+  class Event
+    def as_json(options = {})
+      raise NotImplementedError.new
+    end
+
+    def to_json(options = {})
+      Util::Hash.compact(as_json).to_json(options)
+    end
+  end
+end

data/lib/timber/events/controller_call.rb

@@ -0,0 +1,40 @@
+module Timber
+  module Events
+    # The controller call event tracks controller invocations. For example, this line in Rails:
+    #
+    #   Processing by PagesController#home as HTML
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActionControllerLogSubscriber} probe.
+    class ControllerCall < Timber::Event
+      attr_reader :controller, :action, :params, :format
+
+      def initialize(attributes)
+        @controller = attributes[:controller] || raise(ArgumentError.new(":controller is required"))
+        @action = attributes[:action] || raise(ArgumentError.new(":action is required"))
+        @params = attributes[:params]
+        @format = attributes[:format]
+      end
+
+      def to_hash
+        {controller: controller, action: action}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:controller_call => to_hash}
+      end
+
+      def message
+        message = "Processing by #{controller}##{action}"
+        if !message.nil?
+          message << " as #{format}"
+        end
+        if !params.nil? && params.length > 0
+          message << "\n  Parameters: #{params.inspect}"
+        end
+        message
+      end
+    end
+  end
+end

data/lib/timber/events/custom.rb

@@ -0,0 +1,42 @@
+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)
+        @type = attributes[:type] || raise(ArgumentError.new(":type is required"))
+        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
+        @data = attributes[:data]
+      end
+
+      def to_hash
+        {type => data}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:custom => to_hash}
+      end
+
+      def to_json(options = {})
+        as_json().to_json(options)
+      end
+    end
+  end
+end

data/lib/timber/events/exception.rb

@@ -0,0 +1,35 @@
+module Timber
+  module Events
+    # The exception event is used to track exceptions.
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActionDispatchDebugExceptions} probe.
+    class Exception < Timber::Event
+      attr_reader :name, :exception_message, :backtrace
+
+      def initialize(attributes)
+        @name = attributes[:name] || raise(ArgumentError.new(":name is required"))
+        @exception_message = attributes[:exception_message] || raise(ArgumentError.new(":exception_message is required"))
+        @backtrace = attributes[:backtrace]
+      end
+
+      def to_hash
+        {name: name, message: exception_message, backtrace: backtrace}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:exception => to_hash}
+      end
+
+      def message
+        message = "#{name} (#{exception_message}):"
+        if backtrace.is_a?(Array) && backtrace.length > 0
+          message << "\n\n"
+          message << backtrace.join("\n")
+        end
+        message
+      end
+    end
+  end
+end

data/lib/timber/events/http_request.rb

@@ -0,0 +1,50 @@
+module Timber
+  module Events
+    # The HTTP request event tracks incoming HTTP requests.
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActionControllerLogSubscriber} probe.
+    class HTTPRequest < Timber::Event
+      attr_reader :host, :method, :path, :port, :query_params, :content_type,
+        :remote_addr, :referrer, :request_id, :user_agent
+
+      def initialize(attributes)
+        @host = attributes[:host] || raise(ArgumentError.new(":host is required"))
+        @method = attributes[:method] || raise(ArgumentError.new(":method is required"))
+        @path = attributes[:path] || raise(ArgumentError.new(":path is required"))
+        @port = attributes[:port]
+        @query_params = attributes[:query_params]
+        @content_type = attributes[:content_type]
+        @remote_addr = attributes[:remote_addr]
+        @referrer = attributes[:referrer]
+        @request_id = attributes[:request_id]
+        @user_agent = attributes[:user_agent]
+      end
+
+      def to_hash
+        {host: host, method: method, path: path, port: port, query_params: query_params,
+          headers: {content_type: content_type, remote_addr: remote_addr, referrer: referrer,
+            request_id: request_id, user_agent: user_agent}}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        hash = to_hash
+        hash[:headers] = Util::Hash.compact(hash[:headers])
+        hash = Util::Hash.compact(hash)
+        {:http_request => hash}
+      end
+
+      def message
+        'Started %s "%s" for %s' % [
+        method,
+        path,
+        remote_addr]
+      end
+
+      def status_description
+        Rack::Utils::HTTP_STATUS_CODES[status]
+      end
+    end
+  end
+end

data/lib/timber/events/http_response.rb

@@ -0,0 +1,36 @@
+module Timber
+  module Events
+    # The HTTP response event tracks outgoing HTTP request responses.
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActionControllerLogSubscriber} probe.
+    class HTTPResponse < Timber::Event
+      attr_reader :status, :time_ms, :additions
+
+      def initialize(attributes)
+        @status = attributes[:status] || raise(ArgumentError.new(":status is required"))
+        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
+        @additions = attributes[:additions]
+      end
+
+      def to_hash
+        {status: status, time_ms: time_ms}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:http_response => to_hash}
+      end
+
+      def message
+        message = "Completed #{status} #{status_description} in #{time_ms}ms"
+        message << " (#{additions.join(" | ".freeze)})" unless additions.empty?
+        message
+      end
+
+      def status_description
+        Rack::Utils::HTTP_STATUS_CODES[status]
+      end
+    end
+  end
+end

data/lib/timber/events/sql_query.rb

@@ -0,0 +1,26 @@
+module Timber
+  module Events
+    # The SQL query event tracks sql queries to your database.
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActiveRecordLogSubscriber} probe.
+    class SQLQuery < Timber::Event
+      attr_reader :sql, :time_ms, :message
+
+      def initialize(attributes)
+        @sql = attributes[:sql] || raise(ArgumentError.new(":sql is required"))
+        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
+        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
+      end
+
+      def to_hash
+        {sql: sql, time_ms: time_ms}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:sql_query => to_hash}
+      end
+    end
+  end
+end

data/lib/timber/events/template_render.rb

@@ -0,0 +1,26 @@
+module Timber
+  module Events
+    # The template render event track template renderings and their performance.
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActionViewLogSubscriber} probe.
+    class TemplateRender < Timber::Event
+      attr_reader :message, :name, :time_ms
+
+      def initialize(attributes)
+        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
+        @name = attributes[:name] || raise(ArgumentError.new(":name is required"))
+        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
+      end
+
+      def to_hash
+        {name: name, time_ms: time_ms}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:template_render => to_hash}
+      end
+    end
+  end
+end

data/lib/timber/events.rb

@@ -0,0 +1,37 @@
+require "timber/events/controller_call"
+require "timber/events/custom"
+require "timber/events/exception"
+require "timber/events/http_request"
+require "timber/events/http_response"
+require "timber/events/sql_query"
+require "timber/events/template_render"
+
+module Timber
+  module Events
+    # Protocol for casting objects into a `Timber::Event`.
+    #
+    # @example Casting a hash
+    #   Timber::Events.build({type: :custom_event, message: "My log message", data: {my: "data"}})
+    def self.build(obj)
+      if obj.is_a?(::Timber::Event)
+        obj
+      elsif obj.respond_to?(:to_timber_event)
+        obj.to_timber_event
+      elsif obj.is_a?(Hash) && obj.key?(:message) && obj.key?(:type) && obj.key?(:data)
+        Events::Custom.new(
+          type: obj[:type],
+          message: obj[:message],
+          data: obj[:data]
+        )
+      elsif obj.is_a?(Struct) && obj.respond_to?(:message) && obj.respond_to?(:type)
+        Events::Custom.new(
+          type: obj.type,
+          message: obj.message,
+          data: obj.respond_to?(:hash) ? obj.hash : obj.to_h # ruby 1.9.3 does not have to_h
+        )
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/timber/frameworks/rails.rb

@@ -1,24 +1,13 @@
 module Timber
   module Frameworks
     module Rails
+      # Installs Timber into your Rails app automatically.
       class Railtie < ::Rails::Railtie
         config.timber = Config.instance
         config.before_initialize do
-          Bootstrap.bootstrap!(config.app_middleware, ::Rails::Rack::Logger)
+          Probes.insert!(config.app_middleware, ::Rails::Rack::Logger)
         end
       end
-
-      def self.base_logger(logdev)
-        defined?(::ActiveSupport::Logger) ?
-          ::ActiveSupport::Logger.new(logdev) :
-          ::Logger.new(logdev)
-      end
-
-      def self.logger(logdev)
-        defined?(::ActiveSupport::TaggedLogging) ?
-          ::ActiveSupport::TaggedLogging.new(base_logger(logdev)) :
-          base_logger(logdev)
-      end
     end
   end
-end
+end

data/lib/timber/frameworks.rb

@@ -2,20 +2,18 @@ require "logger"
 
 # Attempt to require Rails. We can not list it as a gem
 # dependency because we want to support multiple frameworks.
-require("rails") rescue LoadError
+begin
+  require("rails")
+rescue LoadError
+end
 
-if defined?(Rails)
+if defined?(::Rails) && defined?(::Rails::Railtie)
   require 'timber/frameworks/rails'
 end
 
 module Timber
+  # Namespace for installing Timber into frameworks
+  # @private
   module Frameworks
-    def self.logger(logdev)
-      if defined?(Timber::Frameworks::Rails)
-        Rails.logger(logdev)
-      else
-        ::Logger.new(logdev)
-      end
-    end
   end
-end
+end

data/lib/timber/log_devices/http.rb

@@ -1,27 +1,86 @@
-require File.join(File.dirname(__FILE__), "http", "log_pile")
-require File.join(File.dirname(__FILE__), "http", "log_truck")
+require "monitor"
+require "msgpack"
 
 module Timber
   module LogDevices
-    class HTTP < LogDevice
-      SPLIT_LINES = false
+    # A log device that buffers and sends logs to the Timber API over HTTP in intervals. The buffer
+    # uses MessagePack::Buffer, which is fast, efficient with memory, and reduces
+    # the payload size sent to Timber.
+    class HTTP
+      class DeliveryError < StandardError; end
 
-      attr_reader :application_key
+      API_URI = URI.parse("https://api.timber.io/http_frames")
+      CONTENT_TYPE = "application/json".freeze
+      CONNECTION_HEADER = "keep-alive".freeze
+      USER_AGENT = "Timber Ruby Gem/#{Timber::VERSION}".freeze
 
-      def initialize(application_key = nil)
-        @application_key = application_key || Config.application_key
-        if @application_key.nil?
-          raise ArgumentError.new("A Timber application_key is required")
+      HTTPS = Net::HTTP.new(API_URI.host, API_URI.port).tap do |https|
+        https.use_ssl = true
+        https.read_timeout = 30
+        https.ssl_timeout = 10
+        if https.respond_to?(:keep_alive_timeout=)
+          https.keep_alive_timeout = 60
         end
-        LogTruck.start!
+        https.open_timeout = 10
       end
 
-      def close(*args)
+      DEFAULT_DELIVERY_FREQUENCY = 2.freeze
+
+      # Instantiates a new HTTP log device.
+      #
+      # @param api_key [String] The API key provided to you after you add your application to
+      #   [Timber](https://timber.io).
+      # @param [Hash] options the options to create a HTTP log device with.
+      # @option attributes [Symbol] :frequency_seconds (2) How often the client should
+      #   attempt to deliver logs to the Timber API. The HTTP client buffers logs between calls.
+      def initialize(api_key, options = {})
+        @api_key = api_key
+        @buffer = []
+        @monitor = Monitor.new
+        @delivery_thread = Thread.new do
+          at_exit { deliver }
+          loop do
+            sleep options[:frequency_seconds] || DEFAULT_DELIVERY_FREQUENCY
+            deliver
+          end
+        end
+      end
+
+      def write(msg)
+        @monitor.synchronize {
+          @buffer << msg
+        }
+      end
+
+      def close
+        @delivery_thread.kill
       end
 
       private
-        def write_log_line(log_line)
-          LogPile.get(application_key).drop(log_line)
+        def deliver
+          body = @buffer.read
+
+          request = Net::HTTP::Post.new(API_URI.request_uri).tap do |req|
+            req['Authorization'] = authorization_payload
+            req['Connection'] = CONNECTION_HEADER
+            req['Content-Type'] = CONTENT_TYPE
+            req['User-Agent'] = USER_AGENT
+            req.body = body
+          end
+
+          HTTPS.request(request).tap do |res|
+            code = res.code.to_i
+            if code < 200 || code >= 300
+              raise DeliveryError.new("Bad response from Timber API - #{res.code}: #{res.body}")
+            end
+            Config.instance.logger.debug("Success! #{code}: #{res.body}")
+          end
+
+          @buffer.clear
+        end
+
+        def authorization_payload
+          @authorization_payload ||= "Basic #{Base64.strict_encode64(@api_key).chomp}"
         end
     end
   end

data/lib/timber/log_devices.rb

@@ -1,4 +1,8 @@
-# Order is relevant
-require File.join(File.dirname(__FILE__), "log_devices", "io")
-require File.join(File.dirname(__FILE__), "log_devices", "heroku_logplex")
-require File.join(File.dirname(__FILE__), "log_devices", "http")
+require "timber/log_devices/http"
+
+module Timber
+  # Namespace for all log devices.
+  # @private
+  module LogDevices
+  end
+end

data/lib/timber/log_entry.rb

@@ -0,0 +1,59 @@
+module Timber
+  # Represents a new log entry into the log. This is an intermediary class between
+  # `Logger` and the log device that you set it up with.
+  class LogEntry #:nodoc:
+    DT_PRECISION = 6.freeze
+
+    attr_reader :level, :time, :progname, :message, :context, :event
+
+    # Creates a log entry suitable to be sent to the Timber API.
+    # @param severity [Integer] the log level / severity
+    # @param time [Time] the exact time the log message was written
+    # @param progname [String] the progname scope for the log message
+    # @param message [#to_json] structured data representing the log line event, this can
+    #   be anything that responds to #to_json
+    # @return [LogEntry] the resulting LogEntry object
+    def initialize(level, time, progname, message, context, event)
+      @level = level
+      @time = time.utc
+      @progname = progname
+      @message = message
+      @context = context
+      @event = event
+    end
+
+    def as_json(options = {})
+      options ||= {}
+      hash = {level: level, dt: formatted_dt, message: message}
+
+      if !event.nil?
+        hash[:event] = event
+      end
+
+      if !context.nil? && context.length > 0
+        hash[:context] = context
+      end
+
+      if options[:only]
+        hash.select do |key, _value|
+          options[:only].include?(key)
+        end
+      elsif options[:except]
+        hash.select do |key, _value|
+          !options[:except].include?(key)
+        end
+      else
+        hash
+      end
+    end
+
+    def to_json(options = {})
+      as_json(options).to_json
+    end
+
+    private
+      def formatted_dt
+        @formatted_dt ||= time.iso8601(DT_PRECISION)
+      end
+  end
+end