rnotifier 0.0.6 → 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 50c10d0bf67e250e5ca27a71467daca164c6bdb3
+  data.tar.gz: 7326f599dc1a0d6bdf85a51253bcf3c0931f3e96
+SHA512:
+  metadata.gz: 94f5b55b64acfff14967da646858a232457cbd0008dbf29092b95b2c0d9b273e7420a1c087a25eacc85ef186c871bd8c88cda0cc8b8eb3263eeb053695823302
+  data.tar.gz: 8fcfb420fd001c7a3769bcf2148b586f41ed97ed6f47553a926e1e2fb4304d63936d25274e224b4c8d96cd41049588193a75a8d822a79b5aec5d26d2ddef6cf1

data/Gemfile

@@ -1,6 +1,4 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rnotifier.gemspec
-gem 'rake'
-gem 'json'
 gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jiren Patel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,48 +1,39 @@
-Rnotifier
-=========
+# Rnotifier
 
-Rails 3 Exception catcher gem
+Exception catcher for rack base applications.
 
-Rails application for exception catching : [git@rnotifier.git](https://github.com/joshsoftware/rnotifier)
+## Installation
 
-Usage
------
+Add this line to your application's Gemfile:
 
-Login to [rnotifier.heroku.com](http://rnotifier.heroku.com)
+    gem 'rnotifier'
 
-Create Project and you will get api key.
+And then execute:
 
-In your rails app
+    $ bundle
 
-rails g rnotifier -k "API-KEY"
+Or install it yourself as:
 
-Configuration "config/initializers/rnotifier.rb"
-------------------------------------------------
+    $ gem install rnotifier
 
-**Exception recipients email addresses**
+## Usage
 
-```ruby
-  c.exception_recipients = %w{jiren@joshsoftware.com example@example.com}
-```
+rnotifier install 'API-KEY'  # This will create 'config/rnotifier.yaml' file.
 
-**Set exception notification server. Default is 'http://rnotifier.heroku.com'**
+### Config file options
 
-```ruby
-  c.notification_server = "http://rnotifier.heroku.com"
-```
+- environments: development  #Default is production
+- capture_code: true         #Default false
+- api_host: 'http://yourapp.com' #Default http://rnotifier.com
 
-Sample configuration
---------------------
+## Contributing
 
-```ruby
-Rnotifier::Notifier.config do |c|
-  c.api_key = 'API-KEY'
-  c.exception_recipients = %w{example@example.com}
-  c.notification_server = "http://rnotifier.heroku.com"
-end
-```
-
-Contributing
-------------
-Please send me a pull request so that this can be improved.
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
 
+License
+-------
+This is released under the MIT license.

data/Rakefile

@@ -1,2 +1 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"

data/bin/rnotifier

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+ARGV[0] = 'help' if ARGV.empty?
+
+case ARGV[0]
+  when 'help'
+    puts %Q{
+---- HELP ----
+test  #Test rnotifier configuration is correct and send test exception.
+
+install api-key [environments] #Create config/rnotifier.yaml with api_key and enabled for supplied environments.environments are optionbal, default is production.
+}
+  when 'test'
+    require 'rnotifier'    
+
+    Rnotofier::Config.load_config('config/rnotifier.yml')
+    if Rnotofier::Config.valid?
+      #NOTE: Add test code
+    else
+      puts 'Configuration is invalid. Check api key'
+    end
+  when 'install'
+    if (api_key = ARGV[1]).nil?
+      puts "'api-key' is required. Use like  i.e rnotifier install api-key [environments]"
+    else
+      environments = ARGV[2..-1]
+      Dir.mkdir('config') unless Dir.exists?('config')        
+    
+      File.open('config/rnotifier.yaml', 'w') do |f|
+        f.puts("apikey: #{api_key}\n")
+        f.puts("environments: #{environments.join(', ')}") unless environments.empty?
+        f.puts("capture_code: false")
+        f.close
+      end
+
+      puts "Rnotofier configuration written in config/rnotifier.yaml"
+    end
+end

data/lib/generators/rnotifier/rnotifier_generator.rb

@@ -6,9 +6,6 @@ class RnotifierGenerator < Rails::Generators::Base
 	def add_config
 		if options[:api_key]
 			template 'initializer.rb', 'config/initializers/rnotifier.rb'
-      p "******* INFO *************" 
-      p "Set exception recipients email address in 'config/initializers/rnotifier.rb'"
-      p "i.e. c.exception_recipients => %w{user1@example.com, user2@example.com} "
 		else
 		  p 'Set option --api-key or -k.'
 		end

data/lib/generators/rnotifier/templates/initializer.rb

@@ -1,6 +1,4 @@
 Rnotifier::Notifier.config do |c|
   c.api_key = <%= api_key %>
-  c.exception_recipients = %w{user1@example.com user2@example.com}
-  c.notification_server = "http://rnotifier.heroku.com"
 end
 

data/lib/rnotifier/config.rb

@@ -0,0 +1,85 @@
+module Rnotifier
+  class Config
+    DEFAULT = {
+      :api_host     => 'http://api.rnotifier.com',
+      :api_version  => 'v1', 
+      :notify_path  => 'exception',
+      :ignore_env   => ['development', 'test'],
+      :http_open_timeout => 2,
+      :http_read_timeout => 4
+    }
+
+    CLIENT = "RN-RUBY-GEM:#{Rnotifier::VERSION}"
+
+    class << self
+      attr_accessor :api_key, :notification_path, :environments, :current_env, 
+        :valid, :app_env, :api_host, :ignore_exceptions, :capture_code
+
+      def [](val)
+        DEFAULT[val]
+      end
+
+      def init
+        Rlogger.init
+
+        self.valid = false
+        self.current_env = ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development' 
+        self.environments ||= []
+
+        if self.environments.is_a?(String) || self.environments.is_a?(Symbol)
+          self.environments = self.environments.to_s.split(',')
+        end
+
+        #Return if config environments not include current env
+        return if !self.environments.empty? && !self.environments.include?(self.current_env)
+
+        #Check for ignore env
+        if DEFAULT[:ignore_env].include?(self.current_env) && !self.environments.include?(self.current_env) 
+          return
+        end
+
+        if self.api_key.nil? and !ENV['RNOTIFIER_API_KEY'].nil?
+          self.api_key = ENV['RNOTIFIER_API_KEY']
+        end
+
+        return if self.api_key.to_s.length == 0
+
+        self.api_host ||= DEFAULT[:api_host]
+        self.notification_path = '/' + [DEFAULT[:api_version], DEFAULT[:notify_path], self.api_key].join('/')
+        self.app_env = get_app_env
+        self.ignore_exceptions = self.ignore_exceptions.split(',') if self.ignore_exceptions.is_a?(String)
+
+        self.valid = true 
+      end
+
+      def valid?
+        self.valid
+      end
+
+      def get_app_env
+        {
+          :env => self.current_env,
+          :pid => $$,
+          :host => (Socket.gethostname rescue ''),
+          :user_name => ENV['USER'] || ENV['USERNAME'],
+          :program_name => $PROGRAM_NAME,
+          :app_root => self.app_root,
+          :language => {
+            :name => 'ruby',
+            :version => (RUBY_VERSION rescue ''),
+            :patch_level => (RUBY_PATCHLEVEL rescue ''),
+            :platform =>  (RUBY_PLATFORM rescue ''),
+            :release_date => (RUBY_RELEASE_DATE rescue ''),
+            :ruby_path => Gem.ruby,
+            :gem_path => Gem.path
+          }
+        }
+      end
+
+      def app_root
+        (defined?(Rails) && Rails.respond_to?(:root)) ? Rails.root.to_s : Dir.pwd
+      end
+
+    end
+  end
+end

data/lib/rnotifier/exception_code.rb

@@ -0,0 +1,31 @@
+module Rnotifier
+  class ExceptionCode
+    class << self
+
+      def get(backtrace)
+        return unless backtrace
+        filename, line, method = (backtrace.find{|l| l =~ /^#{Config.app_env[:app_root]}/} || backtrace[0]).split(':')
+        self.find(filename, line.to_i, 3)
+      end
+
+      def find(filename, line_no, wrap_size = 1)
+        s_range = [line_no - wrap_size, 1].max - 1
+        e_range = line_no + wrap_size - 1
+        #s_range, e_range = [ (line_no - wrap_size) > 0 ? line_no - wrap_size : 0, line_no + wrap_size]
+        code = [s_range]
+
+        begin
+          File.open(filename) do |f|
+            f.each_with_index do |line, i|
+              code << line if i >= s_range && i <= e_range
+              break if i > e_range
+            end
+          end
+        rescue Exception => e
+        end
+        code
+      end
+    end
+
+  end
+end

data/lib/rnotifier/exception_data.rb

@@ -0,0 +1,98 @@
+module Rnotifier
+  class ExceptionData
+    attr_reader :env, :request, :exception, :options
+
+    def initialize(exception, env, options = {})
+      @exception = exception
+      @options   = options  
+      if options[:type] == :rack
+        @request = Rack::Request.new(env)
+      else
+        @env = env
+      end
+    end
+
+    def notify
+      return unless Config.valid?
+      return if Config.ignore_exceptions && Config.ignore_exceptions.include?(exception.class.to_s)
+
+
+      begin
+        data = if options[:type] == :rack
+                 self.rack_exception_data
+               else
+                 {:exception => self.exception_data, :extra => self.env }
+               end
+
+        data[:exception][:code] = ExceptionCode.get(data[:exception][:backtrace]) if Config.capture_code
+        data[:context_data] = Thread.current[:rnotifier_context] if Thread.current[:rnotifier_context]
+        data[:data_from] = options[:type]
+        data[:rnotifier_client] = Config::CLIENT 
+
+        Notifier.send(data)
+      rescue Exception => e
+        Rlogger.error("[NOTIFY] #{e.message}")
+        Rlogger.error("[NOTIFY] #{e.backtrace}")
+      ensure
+        Rnotifier.clear_context
+      end
+    end
+
+    def rack_exception_data
+      data = {
+        :occurred_at => Time.now.to_s,
+        :app_env => Rnotifier::Config.app_env,
+        :exception => self.exception_data
+      }
+      data[:request] = {
+        :url               => request.url,
+        :referer_url       => request.referer,
+        :ip                => request.ip,
+        :http_method       => "#{request.request_method}#{' # XHR' if request.xhr?}",
+        :params            => filtered_params,
+        :headers           => self.headers,
+        :session           => request.session
+      }
+
+      data
+    end
+
+    def exception_data
+      {
+        :class_name => exception.class.to_s,
+        :message    => exception.message,
+        :backtrace  => exception.backtrace,
+        :fingerprint => (self.fingerprint rescue nil)
+      }
+    end
+
+    def fingerprint
+      #data[:fingerprint] = Digest::MD5.hexdigest("#{exception.message.gsub(/#<\w*:\w*>/, '')}#{data[:fingerprint]}")
+
+      if exception.backtrace && !exception.backtrace.empty?
+        Digest::MD5.hexdigest(exception.backtrace.join)
+      end
+    end
+
+    def filtered_params
+      if rp = request.env['action_dispatch.parameter_filter'] 
+        ParameterFilter.filter(request.env['action_dispatch.request.parameters'] || request.params, rp)
+      else 
+        ParameterFilter.default_filter(request.params)
+      end
+    end
+
+    HEADER_REGX = /^HTTP_/
+
+    def headers
+      headers = {}
+      request.env.each do |k, v| 
+        headers[k.sub(HEADER_REGX, '').downcase] = v if k =~ HEADER_REGX 
+      end
+      headers['cookie'] = headers['cookie'].sub(/_session=\S+/, '_session=[FILTERED]') if headers['cookie']
+      headers
+    end
+
+
+  end
+end

data/lib/rnotifier/notifier.rb

@@ -1,58 +1,24 @@
 module Rnotifier
-	class Notifier
+  class Notifier
+    class << self
 
-		class << self
-			def config(&block)
-		 		yield(Rnotifier::Configuration)
-				Configuration.validate_config rescue Rlogger.error('[CONFIG] Error from notification server.')
-
-				#Initialize Rails Exception handler
-				Rnotifier::RailsException.initialize #if Configuration.is_valid
-
-				Configuration.filter_params ||= []
-
-				if Configuration.filter_params.empty?
-					Configuration.filter_params.concat(Configuration::FILTER_PARAMS)
-				end
-
-				Configuration.freeze
-			end
-
-			def send_exception(exception_data)
-				exception_data[:params] = filter_params(exception_data[:params])
-				exception_data[:occurred_at] = Time.now 
-
-				t = Thread.new do 
-					begin
-						response = Util.post(Configuration[:notify_path], {:exception_data => exception_data})
-
-						Rlogger.error("[SEND] #{response['message']}") unless response['notify']
-					rescue Exception => e
-						Rlogger.error("[SERVER] #{e.message}")
-						Rlogger.error("[SERVER] #{e.backtrace}")
-					end
-          send_email_notification(exception_data)
-				end
-			end
-
-      def send_email_notification(exception_data)
-        begin
-          EmailNotifier.exception_notify(exception_data).deliver
-        rescue Exception => e
-          Rlogger.error("[MAILER] #{e.message}")
-          Rlogger.error("[MAILER] #{e.backtrace}")
+      def connection
+        @connection ||= Faraday.new(:url => Rnotifier::Config.api_host) do |faraday|
+          faraday.adapter Faraday.default_adapter  
         end
       end
 
-			def filter_params(params = {})
-				return if params.empty?
-
-				Configuration.filter_params.each do |key|
-					params[key] = '[FILTERED]' if params.has_key?(key)
-				end
-				params
-			end
+      def send(data)
+        response = self.connection.post do |req|
+          req.url Rnotifier::Config.notification_path
+          req.headers['Content-Type'] = 'application/json'
+          req.options[:timeout] =  Rnotifier::Config[:http_open_timeout]
+          req.options[:open_timeout] = Rnotifier::Config[:http_read_timeout]
+          req.body =  MultiJson.dump(data)
+        end
 
+        Rlogger.error("[RNOTIFIER SERVER] Response Status:#{response.status}") unless response.status == 200
+      end
     end
-	end
+  end
 end

data/lib/rnotifier/parameter_filter.rb

@@ -0,0 +1,78 @@
+module Rnotifier
+  class ParameterFilter
+
+    DEFAULT_FIELDS = [:password, :password_confirmation, :authorization, :secret, :passwd]
+    FILTERED = '[FILTERED]'
+
+    def self.filter(params, filters)
+      @filter ||= ParameterFilter.new(filters)
+      @filter.filter(params)
+    end
+
+    def self.default_filter(params)
+      @default_filter ||= ParameterFilter.new(DEFAULT_FIELDS)
+      @default_filter.filter(params)
+    end
+
+    def initialize(filters)
+      @filters = filters
+    end
+
+    def filter(params)
+      if @filters && !@filters.empty?
+        compiled_filter.call(params)
+      else
+        params
+      end
+    end
+
+    private
+
+    def compiled_filter
+      @compiled_filter ||= begin
+      regexps, blocks = compile_filter
+
+        lambda do |original_params|
+          filtered_params = {}
+
+          original_params.each do |key, value|
+            if regexps.find { |r| key =~ r }
+              value = FILTERED
+            elsif value.is_a?(Hash)
+              value = filter(value)
+            elsif value.is_a?(Array)
+              value = value.map { |v| v.is_a?(Hash) ? filter(v) : v }
+            elsif blocks
+              key = key.dup
+              value = value.dup rescue value 
+              blocks.each { |b| b.call(key, value) }
+            end
+
+            filtered_params[key] = value
+          end
+
+          filtered_params
+        end
+      end
+    end
+
+    def compile_filter
+      strings, regexps, blocks = [], [], []
+
+      @filters.each do |item|
+        case item
+        when NilClass
+        when Proc
+          blocks << item
+        when Regexp
+          regexps << item
+        else
+          strings << item.to_s
+        end
+      end
+
+      regexps << Regexp.new(strings.join('|'), true) unless strings.empty?
+      [regexps, blocks]
+    end
+  end
+end

data/lib/rnotifier/rack_middleware.rb

@@ -0,0 +1,26 @@
+module Rnotifier
+  class RackMiddleware
+
+    def initialize(app, config_file = nil)
+      @app = app
+      Rnotifier.load_config(config_file) if config_file 
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => e
+        Rnotifier::ExceptionData.new(e, env, {:type => :rack}).notify
+        env['rnotifier.notify'] = true
+        raise e
+      end
+
+      if e = (env['rack.exception'] || env['sinatra.error'])
+        Rnotifier::ExceptionData.new(e, env, {:type => :rack}).notify
+        env['rnotifier.notify'] = true
+      end
+
+      response
+    end
+  end
+end

data/lib/rnotifier/railtie.rb

@@ -0,0 +1,21 @@
+module Rnotifier
+  class Railtie < Rails::Railtie
+
+    initializer 'rnotifier.initialize' do |app|
+
+      file = File.join(Rails.root, 'config', 'rnotifier.yaml')
+      File.exist?(file) ? Rnotifier.load_config(file) : Rnotifier::Config.init
+
+      if Rnotifier::Config.valid?
+        if defined?(ActionDispatch::DebugExceptions)
+          app.middleware.insert_after ActionDispatch::DebugExceptions, Rnotifier::RackMiddleware
+        elsif defined?(ActionDispatch::ShowExceptions)
+          app.middleware.insert_after ActionDispatch::ShowExceptions, Rnotifier::RackMiddleware
+        else
+          app.middleware.use Rnotifier::RackMiddleware
+        end
+      end
+    end
+
+  end
+end

data/lib/rnotifier/rlogger.rb

@@ -1,26 +1,28 @@
 module Rnotifier
 	class Rlogger
-
-		LOG_TITLE = '[RNOTIFIER]'
-
+		TAG = '[RNOTIFIER]'
 		class << self
 
-			def info(msg)
-				logger.info("#{LOG_TITLE}#{msg}")
-			end
-
-			def error(msg)
-				logger.error("#{LOG_TITLE}#{msg}")
-			end
-
-			def warn(msg)
-				logger.warn("#{LOG_TITLE}#{msg}")
-			end
+      ['info', 'error', 'warn'].each do |level|
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{level}(msg)
+			   	  logger.#{level}("#{TAG} \#{msg}")
+          end
+        METHOD
+      end
+      
+      def init
+        @logger = if defined?(Rails) && Rails.respond_to?(:logger) 
+                    Rails.logger
+                  else
+                    require 'logger' unless defined?(Logger)
+                    Logger.new($stdout)
+                  end
+      end
 
-			private 
-			def logger
-				@rlogger ||= (defined?(Rails.logger) ? Rails.logger : Logger.new(STDERR))
-			end
+      def logger
+        @logger
+      end
 
 		end
 	end

data/lib/rnotifier/version.rb

@@ -1,3 +1,3 @@
 module Rnotifier
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 end