rf_logger 0.0.4 → 0.3.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MjNhYTQ2MGY4ZGU0MTVhOGU2ODdhM2IwMmU1MGVmMWNlZWM5MGYyYg==
-  data.tar.gz: !binary |-
-    ZTNhNDcxZmQ0MWUxODE1MjdlYTFmZGFlMzhkOTI1MmEzYjI3ZTk5MA==
+SHA1:
+  metadata.gz: 2e5e11c14fc59ec80d79f806e6499f3d24204a21
+  data.tar.gz: 6b5b1ebd0c6f083d64c11ed070ec3d7ca9024a24
 SHA512:
-  metadata.gz: !binary |-
-    M2Y1ZjNmODBmM2JkY2EzODU4NGE4ZTcyZWZhOTVlOGUxN2MwNTQ5OGE0OTli
-    OWNiN2RiZWJlZGQzNzFjNjkzOWMwZDg1NjhjODAwYTNmOWFmNDk5MGY3NTEw
-    OTYxZDI2YTA4YWNmNjQ5NWMyMzFiNGE3OWY5YWIyOGU3MjNmYzg=
-  data.tar.gz: !binary |-
-    MzUxZGJkYTdkMjQzMTkxZWU5NDFmZmYyZmVkOTI3ZWM3NWJiODZjMzM0N2I2
-    YWViNzgzMGQ0MzFiMTA1OTNkMDE2ZWM5ZDJhOGEzMGUyNGQyZjdhZWRiMmU2
-    YzVkOGViNWNhNjkyMmRmYWNlNDIxNjUyZTU2N2FhMDk3MDA0YTQ=
+  metadata.gz: 92ee70365528780fa73a8a48b2abc608e938c23f48b2bce20ce026bc501c12195ffa7decb8d5f1772071131c9d5e5a1523d2d749bee2e1263c29d22f98aebf88
+  data.tar.gz: 5ad0b5c67ba647eb012f2789596eedc0be6b8ad724814ac45d4b4f7d1783565cf20f3ab36076cb553f813b1202b9d7ead4d9a9fb2a5ac1968996e6c1c61091e2

data/.rspec

@@ -1,3 +1,3 @@
 --color
---format=nested
+--format=documentation
 --require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+- 2.1.7

data/README.md

@@ -12,8 +12,105 @@ The API provides helper methods for each severity (i.e. `Logger.debug`).  In add
 - target_type (We use this in cases where we want to tie a log record to a particular entity or object in the database, for example User)
 - target_id (This is used in conjunction with target_type, as the unique identifier for the relevant entity)
 - metadata (Additional information such as error details and backtraces or other messages, stored as a hash)
+    * Include in this Hash is the rf_logger_request_tags, which by default contains the request_id if available.
+
+This gem includes RfLogger::SimpleLogger, RfLogger::Sequel::Logger and RfLogger::ActiveRecord::Logger loggers as options that adhere to this API.  The fields above should be passed into helper methods as a hash.
+
+##Integration##
+Integrating RfLogger into your project requires the following steps:
+* Include the rf_logger code in your project
+* Create a migration 
+* Add a model
+
+#### Including rf_logger ####
+Currently, RfLogger is included from the Github repo. Place the following in your Gemfile:
+
+```gem 'rf_logger', :github => 'renewablefunding/rf_logger' , :tag => "0.3.0"```
+
+Also make sure you include rf_logger and the logger you're going to be using:
+
+
+#### Rails
+ 
+##### Requirements
+
+Support Rails `3.2` to `~> 5.0`
+
+##### Features
+
+Alters Rails.logger to append `request_id=89f25715-3e5d-4d85-9352-843a1aeec7d0`
+
+#### Rory Requirements
+
+Support Rory => `0.7`
+
+#### RfLogger::RequestHeaders
+
+*If in the context of a request*
+```ruby
+RfLogger::RequestHeaders.new(type: nil).to_hash
+    #=> {"X-Request-Id" => "89f25715-3e5d-4d85-9352-843a1aeec7d0"}
+
+```
+
+*It defaults to content type of JSON*
+```ruby
+RfLogger::RequestHeaders.new.to_hash
+    #=> {"Content-Type" => "application/json"}
+
+```
+
+*Any additional headers can be added*
+```ruby
+RfLogger::RequestHeaders.new(accepts: "application/json").to_hash
+    #=> {"Content-Type" => "application/json", "Accepts" => "application/json"}
+
+```
+
+#### Migration
+Assuming your logger will persist to a database, you'll need to create a table. While the api should make it pretty easy to determine which fields you'll need, here are the guts of what you'd need for both the SequelLogger and RailsLogger:
+######Sequel
+```
+create_table :logs do
+    primary_key :id
+    column :actor, :text, :null => false
+    column :action, :text, :null => false
+    column :target_type, :text
+    column :target_id, :text
+    column :metadata, :text
+    column :created_at, 'timestamp with time zone', :null => false
+    Integer :level, :null => false, :default => 0
+end
+```
+
+###### ActiveRecord
+```
+create_table :logs do |table|
+    table.integer :level, null: false, default: 0
+    table.string :actor
+    table.string :action
+    table.string :target_type
+    table.string :target_id
+    table.string :metadata
+    table.timestamps null: false
+end
+```
+
+#### Model
+Again, assuming you'll be using the SequelLogger or RailsLogger (or some other logger that persists to a datasource), you'll want to create a Model that wraps your logger. This is as simple as creating a class that inherits from your logger (though you can make it more complex as your project needs dictate):
+
+######Sequel
+```
+class Log < RfLogger::Sequel::Logger
+end
+```
+
+######ActiveRecord
+```
+class Log < RfLogger::ActiveRecord::Logger
+end
+```
 
-This gem includes RfLogger::SimpleLogger and RfLogger::Sequel logger as two options that adhere to this API.  The fields above should be passed into helper methods as a hash.
 
 ##Configuration##
 Configuration mostly sets up additional notifications beyond the actual logging.
@@ -32,7 +129,7 @@ RfLogger.configure do |c|
 end
 ```
 
-As you seen above, you can specify different notifications for different levels or environments whend you log an event.
+As you see above, you can specify different notifications for different levels or environments when you log an event.
 
 ##Notification##
 While you have to implement notifiers yourself, the API is fairly simple.  The class must respond to .send_notification.  The argument passed in is an object that includes a #subject (which can be defined in the configuration (see above), and #details, which is the metadata in YAML format.  Future versions of this may allow for other transformations of the log data.

data/lib/rf_logger/active_record/logger.rb

@@ -0,0 +1,35 @@
+require 'active_record'
+require "rf_logger/request/request_tags"
+require "rf_logger/levels"
+
+module RfLogger
+  module ActiveRecord
+    class Logger < ::ActiveRecord::Base
+      self.table_name = "logs"
+      extend RfLogger::RequestTags
+      class << self
+
+        RfLogger::LEVELS.each do |level|
+          define_method level.to_sym do |entry|
+            add level, entry
+          end
+        end
+
+        def add(level, entry)
+          attributes = {
+            :level       => RfLogger::LEVELS.index(level.to_sym),
+            :action      => entry[:action],
+            :actor       => entry[:actor],
+            :metadata    => entry[:metadata] || {},
+            :target_type => entry[:target_type],
+            :target_id   => entry[:target_id],
+          }
+          attributes[:metadata].merge!(request_tags: rf_logger_request_tags) unless rf_logger_request_tags.nil?
+          create(attributes)
+        end
+      end
+    end
+  end
+end
+
+RfLogger::RailsLogger = RfLogger::ActiveRecord::Logger

data/lib/rf_logger/active_record.rb

@@ -0,0 +1 @@
+require "rf_logger/active_record/logger"

data/lib/rf_logger/configuration.rb

@@ -61,7 +61,7 @@ module RfLogger
 
     def framework_environment
       case
-        when defined?(Rails) then Rails.env
+        when defined?(::Rails) then ::Rails.env
         when defined?(Rory) then ENV['RORY_STAGE']
         when defined?(Padrino) then Padrino.environment
         when defined?(Sinatra::Application) then Sinatra::Application.environment

data/lib/rf_logger/notifications/error_notification_environment_constraints.rb

@@ -17,7 +17,8 @@ module RfLogger
 
       def excluded?
         except = @constraints[:except]
-        except && except.include?(@environment)
+        return false if except.nil?
+        except.include?(@environment)
       end
     end
   end

data/lib/rf_logger/rails/initialize_request_middleware.rb

@@ -0,0 +1,9 @@
+require "rf_logger/request/request_middleware"
+
+module RfLogger
+  class InitializeRequestMiddleware < Rails::Railtie
+    initializer "rf_logging.initialize_request_middleware" do |app|
+      app.middleware.insert_after ::ActionDispatch::RequestId, RequestMiddleware
+    end
+  end
+end

data/lib/rf_logger/rails/key_value_tagged_logging.rb

@@ -0,0 +1,58 @@
+require "rails/rack/logger"
+
+module Rails
+  module Rack
+    module TagsAsKeyValue
+      def initialize(app, taggers={})
+        super
+        @taggers      = taggers.values
+        @taggers_keys = taggers.keys
+      end
+
+      protected def compute_tags(*args)
+        super(*args).collect.with_index do |value, index|
+          "#{@taggers_keys[index]}=#{value}"
+        end
+      end
+    end
+
+    Logger.prepend(TagsAsKeyValue)
+  end
+end
+
+require "active_support/tagged_logging"
+
+module ActiveSupport
+  module RfTagsText
+    def tags_text
+      tags = current_tags
+      if tags.any?
+        tags.collect { |tag| "#{tag} " }.join
+      end
+    end
+  end
+
+  if defined? TaggedLogging::Formatter # Rails 4 or greater
+    TaggedLogging::Formatter.prepend(RfTagsText)
+  else
+    TaggedLogging.prepend(RfTagsText) # Rails 3.2
+  end
+end
+
+require "action_dispatch/middleware/request_id"
+
+module ActionDispatch
+  class RequestId
+    private def internal_request_id
+      [Rails.application.class.parent_name.underscore, SecureRandom.uuid].join("-")
+    end
+  end
+end
+
+require "rails/engine/railties"
+
+class KeyValueKeyLogging < ::Rails::Railtie
+  initializer "rf_logging.add_log_tag_request_id" do |app|
+    app.config.log_tags = { request_id: :uuid }
+  end
+end

data/lib/rf_logger/rails/rails_compatibility.rb

@@ -0,0 +1,33 @@
+module RfLogger
+  class RailsCompatibility
+    MAX = "5.0.99"
+    MIN = "3.2"
+    Incompatible = Class.new(StandardError)
+
+    def initialize(rails_version: Gem::Version.new(::Rails::VERSION::STRING))
+      @rails_version = rails_version
+    end
+
+    def call
+      if rails_supported?
+        yield
+      else
+        rails_not_support_message
+      end
+    end
+
+    private
+
+    attr_reader :rails_version
+
+    def rails_not_support_message
+      raise Incompatible, "These patches change Rails private methods and are only known to work for Rails #{MIN} through #{MAX}"
+    end
+
+    def rails_supported?
+      rails_version >= Gem::Version.new(MIN) && rails_version <= Gem::Version.new(MAX)
+    end
+  end
+end
+
+

data/lib/rf_logger/rails.rb

@@ -0,0 +1,5 @@
+require "rf_logger/rails/rails_compatibility"
+require "rails/version"
+RfLogger::RailsCompatibility.new.call { require "rf_logger/rails/key_value_tagged_logging" }
+require "rf_logger/request/request_headers"
+require "rf_logger/rails/initialize_request_middleware"

data/lib/rf_logger/request/request_headers.rb

@@ -0,0 +1,34 @@
+module RfLogger
+  class RequestHeaders
+    attr_reader :api_token, :type, :request_id, :content_type, :other
+
+    def initialize(type: "application/json",
+                   api_token: nil,
+                   request_id: self.class.request_id,
+                   other: {},
+                   **other_key_headers)
+      @type              = type
+      @api_token         = api_token
+      @request_id        = request_id
+      @content_type      = type
+      @other             = other
+      @other_key_headers = other_key_headers
+    end
+
+    def self.request_id
+      (Thread.current.get_inheritable_attribute(:rf_logger_request_tags)||{})[:request_id]
+    end
+
+    def to_hash
+      {
+        "Content-Type" => content_type,
+        "Api-Token"    => api_token,
+        "X-Request-Id" => request_id
+      }.merge(other_key_headers).merge(other).reject { |_, v| v.nil? }
+    end
+
+    def other_key_headers
+      @other_key_headers.each_with_object({}) { |(k, v), h| h[k.to_s.split("_").map(&:capitalize).join("-")] = v }
+    end
+  end
+end

data/lib/rf_logger/request/request_middleware.rb

@@ -0,0 +1,30 @@
+require "thread/inheritable_attributes"
+
+module RfLogger
+  class RequestMiddleware
+    # @param [Hash] options
+    # @option opts [Hash{:label => "header_name"}] :tagged The subject
+    def initialize(app, options={})
+      @app                = app
+      @tagged             = options.fetch(:tagged, { request_id: "X-Request-Id" })
+    end
+
+    def call(env)
+      @env = env
+      set_tagged_thread_var
+      @app.call(@env)
+    end
+
+    def tagged
+      @tagged.each_with_object({}) do |(key, value), hash|
+        hash[key] = @env[value]
+      end
+    end
+
+    private
+
+    def set_tagged_thread_var
+      Thread.current.set_inheritable_attribute(:rf_logger_request_tags, tagged)
+    end
+  end
+end

data/lib/rf_logger/request/request_tags.rb

@@ -0,0 +1,9 @@
+require "thread/inheritable_attributes"
+
+module RfLogger
+  module RequestTags
+    def rf_logger_request_tags
+      Thread.current.get_inheritable_attribute(:rf_logger_request_tags)
+    end
+  end
+end

data/lib/rf_logger/rory/initialize_request_middleware.rb

@@ -0,0 +1,7 @@
+require "rf_logger/request/request_middleware"
+unless Gem::Version.new(Rory::VERSION) >= Gem::Version.new("0.8")
+  raise "RfLogger require Rory 0.8 or greater. Version #{Rory::VERSION} is not support."
+end
+Rory::Application.initializers.insert_after "rory.request_middleware", "rf_logger.request_middleware" do |app|
+  app.middleware.insert_after Rory::RequestId, RfLogger::RequestMiddleware
+end

data/lib/rf_logger/rory.rb

@@ -0,0 +1,2 @@
+require "rf_logger/rory/initialize_request_middleware"
+require "rf_logger/request/request_headers"

data/lib/rf_logger/sequel/base.rb

@@ -0,0 +1,46 @@
+require 'forwardable'
+require 'rf_logger/version'
+require 'rf_logger/configuration'
+require 'rf_logger/levels'
+
+require 'rf_logger/notifications/error_notification'
+require 'rf_logger/notifications/error_notification_environment_constraints'
+
+require 'rf_logger/simple_logger'
+require 'rf_logger/log_for_notification'
+
+
+module RfLogger
+  class UndefinedSetting < StandardError; end
+
+  class << self
+    extend Forwardable
+
+    Configuration.defined_settings.each do |setting|
+      def_delegators :configuration, setting, "#{setting.to_s}="
+    end
+
+    def configuration
+      @configuration ||= RfLogger::Configuration.new
+    end
+
+    def configure(&block)
+      unless block
+        raise ArgumentError.new("You tried to .configure without a block!")
+      end
+      yield configuration
+    end
+
+    def clear_configuration!
+      @configuration = nil
+    end
+
+    def configure!(&block)
+      unless block
+        raise ArgumentError.new('You tried to .configure without a block!')
+      end
+      clear_configuration!
+      yield configuration
+    end
+  end
+end

data/lib/rf_logger/sequel/logger.rb

@@ -0,0 +1,53 @@
+require "json"
+require "rf_logger/sequel/base"
+require "rf_logger/request/request_tags"
+
+module RfLogger
+  module Sequel
+    class Logger < ::Sequel::Model(::Sequel::Model.db.fetch('select 1'))
+      extend RfLogger::RequestTags
+
+      class << self
+        def inherited(subclass)
+          super
+          subclass.set_dataset underscore(demodulize(subclass.name.pluralize)).to_sym
+        end
+
+        RfLogger::LEVELS.each do |level|
+          define_method level.to_sym do |entry|
+            log = add level, entry
+
+            notification_log = LogForNotification.new(entry.merge(:level => level))
+            ErrorNotification.dispatch_error(notification_log)
+            log
+          end
+        end
+
+        def add(level, entry)
+          entry[:level]    = RfLogger::LEVELS.index(level.to_sym)
+          entry[:actor]    = entry[:actor] || ''
+          entry[:metadata] = entry[:metadata] || {}
+          entry[:metadata].merge!(request_tags: rf_logger_request_tags) unless rf_logger_request_tags.nil?
+          entry[:created_at] = Time.now
+          create(entry)
+        end
+      end
+
+      def metadata
+        return nil if self[:metadata].nil?
+        JSON.parse(self[:metadata])
+      end
+
+      def metadata=(metadata_hash)
+        metadata_as_json = metadata_hash.nil? ? nil : metadata_hash.to_json
+        self[:metadata]  = metadata_as_json
+      end
+
+      def display_level
+        RfLogger::LEVELS[level]
+      end
+    end
+  end
+end
+
+RfLogger::SequelLogger = RfLogger::Sequel::Logger

data/lib/rf_logger/sequel.rb

@@ -0,0 +1,2 @@
+require "rf_logger/sequel/base"
+require "rf_logger/sequel/model"

data/lib/rf_logger/version.rb

@@ -1,3 +1,3 @@
 module RfLogger
-  VERSION = "0.0.4"
+  VERSION = "0.3.0"
 end

data/lib/rf_logger.rb

@@ -1,47 +1,18 @@
-require 'forwardable'
-require 'yaml'
-require 'rf_logger/version'
-require 'rf_logger/configuration'
-require 'rf_logger/levels'
-
-require 'rf_logger/notifications/error_notification'
-require 'rf_logger/notifications/error_notification_environment_constraints'
-
-require 'rf_logger/simple_logger'
-require 'rf_logger/log_for_notification'
-
+require "rf_logger/version"
 
 module RfLogger
-  class UndefinedSetting < StandardError; end
-
-  class << self
-    extend Forwardable
-
-    Configuration.defined_settings.each do |setting|
-      def_delegators :configuration, setting, "#{setting.to_s}="
-    end
-
-    def configuration
-      @configuration ||= RfLogger::Configuration.new
-    end
-
-    def configure(&block)
-      unless block
-        raise ArgumentError.new("You tried to .configure without a block!")
-      end
-      yield configuration
-    end
-
-    def clear_configuration!
-      @configuration = nil
-    end
-
-    def configure!(&block)
-      unless block
-        raise ArgumentError.new('You tried to .configure without a block!')
-      end
-      clear_configuration!
-      yield configuration
+  def self.try_to_load(file)
+    begin
+      require file
+      yield
+      puts "RfLogger: Detected #{file}." if ENV["RF_LOGGER_LOAD_DEBUG"]
+    rescue LoadError
+      puts "RfLogger: #{file} not detected." if ENV["RF_LOGGER_LOAD_DEBUG"]
     end
   end
 end
+
+RfLogger.try_to_load("rails")         { require "rf_logger/rails" }
+RfLogger.try_to_load("active_record") { require "rf_logger/active_record" }
+RfLogger.try_to_load("rory")          { require "rf_logger/rory" }
+RfLogger.try_to_load("sequel")        { require "rf_logger/sequel" }

data/rf_logger.gemspec

@@ -5,11 +5,11 @@ require 'rf_logger/version'
 
 Gem::Specification.new do |s|
   s.name        = 'rf_logger'
-  s.version     = '0.0.4'
+  s.version     = RfLogger::VERSION
   s.date        = '2014-02-20'
   s.summary     = "A logger that adheres to Renewable Funding logging conventions"
   s.description = "A logger that allows specification of severity, applicable entity/records, metadata, and optional notifications"
-  s.authors     = ["Dave Miller", "Laurie Kemmerer", "Maher Hawash", "Ravi Gadad"]
+  s.authors     = ["Dustin Zeisler", "Dave Miller", "Laurie Kemmerer", "Maher Hawash", "Ravi Gadad"]
   s.email       = 'devteam@renewfund.com'
   s.homepage    = ''
   s.license     = 'MIT'
@@ -19,11 +19,11 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
+  s.add_runtime_dependency "thread-inheritable_attributes", "~> 0.1"
   s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'watchr'
-  s.add_development_dependency 'debugger'
+  s.add_development_dependency 'rspec', "~> 3.4"
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'sequel'
+  s.add_development_dependency 'activerecord'
 end

data/spec/lib/rf_logger/active_record/logger_spec.rb

@@ -0,0 +1,49 @@
+require "rf_logger/active_record/logger"
+require "active_record"
+
+describe RfLogger::ActiveRecord::Logger do
+  include_examples "RfLogger::RequestId", subject: described_class
+
+  it "keeps backwards compatibility" do
+    expect(described_class).to eq RfLogger::RailsLogger
+  end
+
+  RfLogger::LEVELS.each do |level|
+    before do
+      allow(described_class).to receive(:create)
+      allow(described_class).to receive(:table_name)
+    end
+
+    describe ".#{level}" do
+      context "when rf_logger_request_tags is empty" do
+        it "creates new Log object with level = #{level}" do
+          allow(described_class).to receive(:rf_logger_request_tags){nil}
+          described_class.send(level.to_sym, action: 'log me')
+          expect(described_class).to have_received(:create).with(
+            :level => RfLogger::LEVELS.index(level.to_sym),
+            :action => 'log me',
+            :actor => nil,
+            :metadata => {},
+            :target_type => nil,
+            :target_id => nil,
+          )
+        end
+      end
+
+      context "when rf_logger_request_tags is not empty" do
+        it "creates new Log object with level = #{level}" do
+          allow(described_class).to receive(:rf_logger_request_tags){{test: "hello"}}
+          described_class.send(level.to_sym, action: 'log me')
+          expect(described_class).to have_received(:create).with(
+            :level => RfLogger::LEVELS.index(level.to_sym),
+            :action => 'log me',
+            :actor => nil,
+            :metadata => {:request_tags => {test: "hello"}},
+            :target_type => nil,
+            :target_id => nil,
+          )
+        end
+      end
+    end
+  end
+end