timber 2.6.2 → 3.0.0

data/lib/timber/contexts/session.rb

@@ -3,35 +3,22 @@ require "timber/util"
 
 module Timber
   module Contexts
-    # The session context adds the current session ID to your logs. This allows you
-    # to tail and filter logs by specific session IDs. Moreover, it gives you a unique
-    # identifier to report on user activity by session. This way your logs can tell the
-    # story of how many time a user has engaged your site.
-    #
-    # @note This is tracked automatically with the {Integrations::Rack::SessionContext} rack
-    #   middleware.
+    # @private
     class Session < Context
-      ID_MAX_BYTES = 256.freeze
-
-      @keyspace = :session
-
       attr_reader :id
 
       def initialize(attributes)
-        normalizer = Util::AttributeNormalizer.new(attributes)
-        @id = normalizer.fetch!(:id, :string, :limit => ID_MAX_BYTES)
+        @id = attributes[:id]
       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)
-        end
-      end
-
-      def as_json(_options = {})
-        to_hash
+        @to_hash ||= {
+          session: Util::NonNilHashBuilder.build do |h|
+            h.add(:id, id)
+          end
+        }
       end
     end
   end
-end
+end

data/lib/timber/contexts/system.rb

@@ -8,29 +8,22 @@ module Timber
     # @note This is tracked automatically in {CurrentContext}. When the current context
     #   is initialized, the system context gets added automatically.
     class System < Context
-      HOSTNAME_MAX_BYTES = 256.freeze
-
-      @keyspace = :system
-
       attr_reader :hostname, :pid
 
       def initialize(attributes)
-        normalizer = Util::AttributeNormalizer.new(attributes)
-        @hostname = normalizer.fetch(:hostname, :string, :limit => HOSTNAME_MAX_BYTES)
-        @pid = normalizer.fetch(:pid, :integer)
+        @hostname = attributes[:hostname]
+        @pid = attributes[:pid]
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
       def to_hash
-        @to_hash ||= Util::NonNilHashBuilder.build do |h|
-          h.add(:hostname, hostname)
-          h.add(:pid, pid)
-        end
-      end
-
-      def as_json(_options = {})
-        to_hash
+        @to_hash ||= {
+          system: Util::NonNilHashBuilder.build do |h|
+            h.add(:hostname, hostname)
+            h.add(:pid, pid)
+          end
+        }
       end
     end
   end
-end
+end

data/lib/timber/contexts/user.rb

@@ -3,46 +3,26 @@ require "timber/util"
 
 module Timber
   module Contexts
-    # The user context adds data about the currently authenticated user to your logs.
-    # By adding this context all of your logs will contain user information. This allows
-    # filter and tail logs by specific users.
-    #
-    # @note This is tracked automatically with the {Integrations::Rack::UserContext} rack
-    #   middleware for supported authentication frameworks. See {Integrations::Rack::UserContext}
-    #   for more details.
+    # @private
     class User < Context
-      ID_MAX_BYTES = 256.freeze
-      NAME_MAX_BYTES = 256.freeze
-      EMAIL_MAX_BYTES = 256.freeze
-      TYPE_MAX_BYTES = 256.freeze
-
-      @keyspace = :user
-
-      attr_reader :id, :name, :email, :type, :meta
+      attr_reader :id, :name, :email
 
       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)
-        @email = normalizer.fetch(:email, :string, :limit => EMAIL_MAX_BYTES)
-        @type = normalizer.fetch(:type, :string, :limit => TYPE_MAX_BYTES)
-        @meta = normalizer.fetch(:meta, :hash)
+        @id = attributes[:id]
+        @name = attributes[:name]
+        @email = attributes[:email]
       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)
-          h.add(:email, email)
-          h.add(:type, type)
-          h.add(:meta, meta)
-        end
-      end
-
-      def as_json(_options = {})
-        to_hash
+        @to_hash ||= {
+          user: Util::NonNilHashBuilder.build do |h|
+            h.add(:id, id)
+            h.add(:name, name)
+            h.add(:email, email)
+          end
+        }
       end
     end
   end
-end
+end

data/lib/timber/current_context.rb

@@ -1,8 +1,6 @@
 require "socket"
 
 require "timber/config"
-require "timber/contexts/release"
-require "timber/contexts/system"
 
 module Timber
   # Holds the current context in a thread safe memory storage. This context is
@@ -21,11 +19,6 @@ module Timber
         Thread.current[THREAD_NAMESPACE] ||= new
       end
 
-      # Convenience method for {CurrentContext#with}. See {CurrentContext#with} for more info.
-      def with(*args, &block)
-        instance.with(*args, &block)
-      end
-
       # Convenience method for {CurrentContext#add}. See {CurrentContext#add} for more info.
       def add(*args)
         instance.add(*args)
@@ -47,32 +40,6 @@ module Timber
       end
     end
 
-    # Adds a context and then removes it when the block is finished executing.
-    #
-    # @note Because context is included with every log line, it is recommended that you limit this
-    #   to only neccessary data.
-    #
-    # @example Adding a custom context
-    #   Timber::CurrentContext.with({build: {version: "1.0.0"}}) do
-    #     # ... anything logged here will include the context ...
-    #   end
-    #
-    # @note Any custom context needs to have a single root key to be valid. i.e. instead of:
-    #   Timber::CurrentContext.with(job_id: "123", job_name: "Refresh User Account")
-    #
-    # do
-    #
-    #   Timber::CurrentContext.with(job: {job_id: "123", job_name: "Refresh User Account"})
-    #
-    # @example Adding multiple contexts
-    #   Timber::CurrentContext.with(context1, context2) { ... }
-    def with(*objects)
-      add(*objects)
-      yield
-    ensure
-      remove(*objects)
-    end
-
     # Adds contexts but does not remove them. See {#with} for automatic maintenance and {#remove}
     # to remove them yourself.
     #
@@ -80,7 +47,7 @@ module Timber
     #   to only neccessary data.
     def add(*objects)
       objects.each do |object|
-        add_to!(hash, object)
+        hash.merge!(object.to_hash)
       end
       expire_cache!
       self
@@ -93,23 +60,9 @@ module Timber
 
     # Removes a context. If you wish to remove by key, or some other way, use {#hash} and
     # modify the hash accordingly.
-    def remove(*objects)
-      objects.each do |object|
-        if object.is_a?(Symbol)
-          hash.delete(object)
-        else
-          context = Contexts.build(object)
-
-          if context.keyspace == :custom
-            # Custom contexts are merged and should be removed the same
-            hash[context.keyspace].delete(context.type)
-            if hash[context.keyspace] == {}
-              hash.delete(context.keyspace)
-            end
-          else
-            hash.delete(context.keyspace)
-          end
-        end
+    def remove(*keys)
+      keys.each do |keys|
+        hash.delete(keys)
       end
       expire_cache!
       self
@@ -127,13 +80,7 @@ module Timber
     # since the context can change as execution proceeds. Note that individual contexts
     # should be immutable, and we implement snapshot caching as a result of this assumption.
     def snapshot
-      @snapshot ||= begin
-        snapshot = hash.clone
-        if snapshot.key?(:custom)
-          snapshot[:custom] = hash[:custom].clone
-        end
-        snapshot
-      end
+      @snapshot ||= hash.clone
     end
 
     private
@@ -149,39 +96,30 @@ module Timber
         new_hash = {}
 
         # Release context
-        release_context = Contexts::Release.from_env
-        if release_context
-          add_to!(new_hash, release_context)
+        release_context = Util::NonNilHashBuilder.build do |h|
+          h.add(:commit_hash, ENV['RELEASE_COMMIT'] || ENV['HEROKU_SLUG_COMMIT'])
+          h.add(:created_at, ENV['RELEASE_CREATED_AT'] || ENV['HEROKU_RELEASE_CREATED_AT'])
+          h.add(:version, ENV['RELEASE_VERSION'] || ENV['HEROKU_RELEASE_VERSION'])
+        end
+
+        if release_context != {}
+          new_hash.merge!({release: release_context})
         end
 
         # System context
         hostname = Socket.gethostname
         pid = Process.pid
         system_context = Contexts::System.new(hostname: hostname, pid: pid)
-        add_to!(new_hash, system_context)
+        new_hash.merge!(system_context.to_hash)
 
         # Runtime context
         thread_object_id = Thread.current.object_id
-        runtime_context = Contexts::Runtime.new(vm_pid: thread_object_id)
-        add_to!(new_hash, runtime_context)
+        runtime_context = {thread_id: thread_object_id}
+        new_hash.merge!({runtime: runtime_context})
 
         new_hash
       end
 
-      def add_to!(hash, object)
-        context = Contexts.build(object) # Normalizes objects into a Timber::Context descendant.
-        key = context.keyspace
-        json = context.as_json # Convert to json now so that we aren't doing it for every line
-        if key == :custom
-          # Custom contexts are merged into the space
-          hash[key] ||= {}
-          hash[key].merge!(json)
-        else
-          hash[key] = json
-        end
-        hash
-      end
-
       # Hook to clear any caching implement in this class
       def expire_cache!
         @snapshot = nil

data/lib/timber/event.rb

@@ -2,12 +2,10 @@ module Timber
   # Base class for `Timber::Events::*`
   # @private
   class Event
-    def message
-      raise NotImplementedError.new
-    end
-
-    def as_json(options = {})
-      raise NotImplementedError.new
+    attr_reader :message, :metadata
+    def initialize(message, metadata)
+      @message = message || ""
+      @metadata = metadata || {}
     end
 
     # This ensures that Timber events get logged as messages if they are passed to
@@ -19,15 +17,20 @@ module Timber
     end
 
     def to_json(options = {})
-      as_json.to_json(options)
+      metadata.to_json(options)
+    end
+
+    def to_hash
+      metadata
     end
+    alias to_h to_hash
 
     def to_msgpack(*args)
-      as_json.to_msgpack(*args)
+      metadata.to_msgpack(*args)
     end
 
     def to_s
       message
     end
   end
-end
+end

data/lib/timber/events.rb

@@ -1,42 +1,10 @@
 require "timber/events/controller_call"
-require "timber/events/custom"
 require "timber/events/error"
-require "timber/events/http_request"
-require "timber/events/http_response"
 require "timber/events/sql_query"
 require "timber/events/template_render"
 
 module Timber
   # Namespace for all Timber supported events.
   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.length == 2
-        event = obj.select { |k,v| k != :message }
-        type = event.keys.first
-        data = event.values.first
-
-        Events::Custom.new(
-          type: type,
-          message: obj[:message],
-          data: 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?(:to_h) ? obj.to_h : Timber::Util::Struct.to_hash(obj) # ruby 1.9.3 does not have to_h :(
-        )
-      else
-        nil
-      end
-    end
   end
-end
+end

data/lib/timber/events/controller_call.rb

@@ -1,43 +1,22 @@
-require "timber/event"
 require "timber/util"
+require "timber/event"
 
 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 integrations,
-    #   such as the {Integrations::ActionController} integration.
+    # @private
     class ControllerCall < Timber::Event
-      ACTION_MAX_BYTES = 256.freeze
-      FORMAT_MAX_BYTES = 256.freeze
-      CONTROLLER_MAX_BYTES = 256.freeze
-      PARAMS_JSON_MAX_BYTES = 32_768.freeze
-      PASSWORD_NAME = 'password'.freeze
-
-      attr_reader :controller, :action, :params, :format
+      attr_reader :controller, :action, :params, :params_json, :format
 
       def initialize(attributes)
-        normalizer = Util::AttributeNormalizer.new(attributes)
-        @controller = normalizer.fetch!(:controller, :string, :limit => CONTROLLER_MAX_BYTES)
-        @action = normalizer.fetch!(:action, :string, :limit => ACTION_MAX_BYTES)
-        @params = normalizer.fetch(:params, :hash, :sanitize => [PASSWORD_NAME])
-        @format = normalizer.fetch(:format, :string, :limit => FORMAT_MAX_BYTES)
-      end
+        @controller = attributes[:controller]
+        @action = attributes[:action]
+        @params = attributes[:params]
 
-      def to_hash
-        @to_hash ||= Util::NonNilHashBuilder.build do |h|
-          h.add(:controller, controller)
-          h.add(:action, action)
-          h.add(:params_json, params.to_json.byteslice(0, PARAMS_JSON_MAX_BYTES))
+        if @params
+          @params_json = @params.to_json
         end
-      end
-      alias to_h to_hash
 
-      # Builds a hash representation containing simple objects, suitable for serialization (JSON).
-      def as_json(_options = {})
-        {:controller_call => to_hash}
+        @format = attributes[:format]
       end
 
       def message
@@ -50,6 +29,16 @@ module Timber
         end
         message
       end
+
+      def to_hash
+        {
+          controller_called: Util::NonNilHashBuilder.build do |h|
+            h.add(:controller, controller)
+            h.add(:action, action)
+            h.add(:params_json, params_json)
+          end
+        }
+      end
     end
   end
-end
+end