validation_tracker_client 2.4.11

data/.gitignore

@@ -0,0 +1,41 @@
+/.idea/*
+.rvmrc
+app/views/**/.tmp_*
+public/images/Thumbs.db
+public/system
+tmp
+public/blank.html
+/.project
+/.loadpath
+/db/sphinx/test
+/db/sphinx/test2
+/db/sphinx/test3
+/db/sphinx/test4
+/db/sphinx/cucumber
+/db/sphinx/development
+/tmp
+/log
+/config/development.sphinx.conf
+/config/test.sphinx.conf
+/config/test2.sphinx.conf
+/config/test3.sphinx.conf
+/config/test4.sphinx.conf
+/config/cucumber.sphinx.conf
+nbproject
+db/development_structure.sql
+db/test_structure.sql
+/results
+cities.txt
+states.txt
+countries.txt
+GPATH
+GRTAGS
+GSYMS
+GTAGS
+webrat.log
+test/fixtures
+.rvmrc
+.gemtags
+.tags
+.tags_sorted_by_file
+pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in validation_tracker_client.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 arun.kumar.arjunan
+
+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

@@ -0,0 +1,29 @@
+# ValidationTrackerClient
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'validation_tracker_client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install validation_tracker_client
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/validation_tracker_client.rb

@@ -0,0 +1,136 @@
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+begin
+  require 'active_support'
+rescue LoadError
+  require 'activesupport'
+end
+require 'validation_tracker_client/version'
+require 'validation_tracker_client/configuration'
+require 'validation_tracker_client/notice'
+require 'validation_tracker_client/sender'
+
+require 'validation_tracker_client/railtie' if defined?(Rails::Railtie)
+
+# Gem for applications to automatically post errors to the Validation Tracker of their choice.
+module ValidationTrackerClient
+
+  API_VERSION = "2.0"
+  LOG_PREFIX = "** [Validation Tracker] "
+
+  HEADERS = {
+    'Content-type'             => 'text/xml',
+    'Accept'                   => 'text/xml, application/xml'
+  }
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the Validation Tracker server.
+    # Must respond to #send_to_validation_tracker. See ValidationTrackerClient::Sender.
+    attr_accessor :sender
+
+    # A Validation Tracker configuration object. Must act like a hash and return sensible
+    # values for all Validation Tracker configuration options. See ValidationTrackerClient::Configuration.
+    attr_accessor :configuration
+
+    # Tell the log that the Notifier is good to go
+    def report_ready
+      write_verbose_log("Notifier #{VERSION} ready to catch errors")
+    end
+
+    # Prints out the environment info to the log for debugging help
+    def report_environment_info
+      write_verbose_log("Environment Info: #{environment_info}")
+    end
+
+    # Prints out the response body from Validation Tracker for debugging help
+    def report_response_body(response)
+      write_verbose_log("Response from Validation Tracker: \n#{response}")
+    end
+
+    # Returns the Ruby version, Rails version, and current Rails environment
+    def environment_info
+      info = "[Ruby: #{RUBY_VERSION}]"
+      info << " [#{configuration.framework}]"
+      info << " [Env: #{configuration.environment_name}]"
+    end
+
+    # Writes out the given message to the #logger
+    def write_verbose_log(message)
+      logger.info LOG_PREFIX + message if logger
+    end
+
+    # Look for the Rails logger currently defined
+    def logger
+      self.configuration.logger
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   ValidationTrackerClient.configure do |config|
+    #     config.api_key = '1234567890abcdef'
+    #     config.secure  = false
+    #   end
+    def configure(silent = false)
+      self.configuration ||= Configuration.new
+      yield(configuration)
+      self.sender = Sender.new(configuration)
+      report_ready unless silent
+    end
+
+    # Sends an exception manually using this method, even when you are not in a controller.
+    #
+    # @param [Exception] exception The exception you want to notify Validation Tracker about.
+    # @param [Hash] opts Data that will be sent to Validation Tracker.
+    #
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Validation Tracker uses for identification.
+    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
+    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
+    # @option opts [String] :request The controller's request object.
+    # @option opts [String] :session The contents of the user's session.
+    # @option opts [String] :environment ENV merged with the contents of the request's environment.
+    def notify(error_message, opts = {})
+      send_notice(build_notice_for(error_message, opts))
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions
+    # @see ValidationTrackerClient.notify
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    def build_lookup_hash_for(exception, options = {})
+      notice = build_notice_for(exception, options)
+
+      result = {}
+      result[:action]           = notice.action      rescue nil
+      result[:component]        = notice.component   rescue nil
+      result[:error_class]      = notice.error_class if notice.error_class
+      result[:environment_name] = 'production'
+
+      unless notice.backtrace.lines.empty?
+        result[:file]        = notice.backtrace.lines.first.file
+        result[:line_number] = notice.backtrace.lines.first.number
+      end
+
+      result
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.public?
+        sender.send_to_validation_tracker(notice.to_xml)
+      end
+    end
+
+    def build_notice_for(error_message, opts = {})
+      opts = opts.merge(:error_message => error_message)
+      Notice.new(configuration.merge(opts))
+    end
+
+  end
+end
+

data/lib/validation_tracker_client/configuration.rb

@@ -0,0 +1,175 @@
+module ValidationTrackerClient
+  # Used to set up and modify settings for the notifier.
+  class Configuration
+
+    OPTIONS = [:api_key, :development_environments,
+        :development_lookup, :environment_name, :host,
+        :http_open_timeout, :http_read_timeout,
+        :notifier_name, :notifier_url, :notifier_version,
+        :params_filters, :project_root, :port, :protocol, :proxy_host,
+        :proxy_pass, :proxy_port, :proxy_user, :secure, :framework,
+        :user_information].freeze
+
+    # The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # The host to connect to (defaults to validation-tracker.heroku.com).
+    attr_accessor :host
+
+    # The port on which your Validation Tracker server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # A list of parameters that should be filtered out of what is sent to Validation Tracker.
+    # By default, all "password" attributes will have their contents replaced.
+    attr_reader :params_filters
+
+    # A list of environments in which notifications should not be sent.
+    attr_accessor :development_environments
+
+    # +true+ if you want to check for production errors matching development errors, +false+ otherwise.
+    attr_accessor :development_lookup
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The path to the project in which the error occurred, such as the RAILS_ROOT
+    attr_accessor :project_root
+
+    # The name of the notifier library being used to send notifications (such as "Validation Tracker Notifier")
+    attr_accessor :notifier_name
+
+    # The version of the notifier library being used to send notifications (such as "1.0.2")
+    attr_accessor :notifier_version
+
+    # The url of the notifier library being used to send notifications
+    attr_accessor :notifier_url
+
+    # The logger used by ValidationTrackerClient
+    attr_accessor :logger
+
+    # The text that the placeholder is replaced with. {{error_id}} is the actual error number.
+    attr_accessor :user_information
+
+    # The framework ValidationTrackerClient is configured to use
+    attr_accessor :framework
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(ValidationTrackerClient.configuration.project_root) && ValidationTrackerClient.configuration.project_root.to_s != '' 
+          line.gsub(/#{ValidationTrackerClient.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/validation_tracker_client} }
+    ].freeze
+
+
+    alias_method :secure?, :secure
+
+    def initialize
+      @secure                   = false
+      @host                     = 'validation-tracker.heroku.com'
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @ignore_user_agent        = []
+      @development_environments = %w(development test cucumber)
+      @development_lookup       = true
+      @notifier_name            = 'Validation Tracker Notifier'
+      @notifier_version         = VERSION
+      @notifier_url             = 'http://validation-tracker.heroku.com'
+      @framework                = 'Standalone'
+      @user_information         = 'Validation Tracker Error {{error_id}}'
+    end
+
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash.merge(option.to_sym => send(option))
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Determines if the notifier will send notices.
+    # @return [Boolean] Returns +false+ if in a development environment, +true+ otherwise.
+    def public?
+      !development_environments.include?(environment_name)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def environment_filters
+      warn 'config.environment_filters has been deprecated and has no effect.'
+      []
+    end
+
+    private
+
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+
+  end
+
+end

data/lib/validation_tracker_client/notice.rb

@@ -0,0 +1,329 @@
+require 'builder'
+require 'socket'
+
+module ValidationTrackerClient
+  class Notice
+
+    # The API key for the project to which this notice should be sent
+    attr_reader :api_key
+
+
+    # The name of the server environment (such as "production")
+    attr_reader :environment_name
+
+    # CGI variables such as HTTP_METHOD
+    attr_reader :cgi_data
+
+    # The message from the exception, or a general description of the error
+    attr_reader :error_message
+
+    # See Configuration#backtrace_filters
+    attr_reader :backtrace_filters
+
+    # See Configuration#params_filters
+    attr_reader :params_filters
+
+    # A hash of parameters from the query string or post body.
+    attr_reader :parameters
+    alias_method :params, :parameters
+
+    # The component (if any) which was used in this request (usually the controller)
+    attr_reader :component
+    alias_method :controller, :component
+
+    # The action (if any) that was called in this request
+    attr_reader :action
+
+    # A hash of session data from the request
+    attr_reader :session_data
+
+    # The path to the project that caused the error (usually RAILS_ROOT)
+    attr_reader :project_root
+
+    # The URL at which the error occurred (if any)
+    attr_reader :url
+
+    # The name of the notifier library sending this notice, such as "Validation Tracker Notifier"
+    attr_reader :notifier_name
+
+    # The version number of the notifier library sending this notice, such as "2.1.3"
+    attr_reader :notifier_version
+
+    # A URL for more information about the notifier library sending this notice
+    attr_reader :notifier_url
+
+    # The host name where this error occurred (if any)
+    attr_reader :hostname
+
+    def initialize(args)
+      self.args         = args
+      self.exception    = args[:exception]
+      self.api_key      = args[:api_key]
+      self.project_root = args[:project_root]
+      self.url          = args[:url] || rack_env(:url)
+
+      self.notifier_name    = args[:notifier_name]
+      self.notifier_version = args[:notifier_version]
+      self.notifier_url     = args[:notifier_url]
+
+      self.params_filters      = args[:params_filters]      || []
+      self.parameters          = args[:parameters] ||
+                                   action_dispatch_params ||
+                                   rack_env(:params) ||
+                                   {}
+      self.component           = args[:component] || args[:controller] || parameters['controller']
+      self.action              = args[:action] || parameters['action']
+
+      self.environment_name = args[:environment_name]
+      self.cgi_data         = args[:cgi_data] || args[:rack_env]
+      self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
+        "#{exception.class.name}: #{exception.message}"
+      end
+
+      self.hostname        = local_hostname
+
+      also_use_rack_params_filters
+      find_session_data
+      clean_params
+      clean_rack_request_data
+    end
+
+    # Converts the given notice to XML
+    def to_xml
+      builder = Builder::XmlMarkup.new
+      builder.instruct!
+      xml = builder.notice(:version => ValidationTrackerClient::API_VERSION) do |notice|
+        notice.tag!("api-key", api_key)
+        notice.notifier do |notifier|
+          notifier.name(notifier_name)
+          notifier.version(notifier_version)
+          notifier.url(notifier_url)
+        end
+        notice.error do |error|
+          error.tag!('class', error_class)
+          error.message(error_message)
+          error.backtrace do |backtrace|
+            self.backtrace.lines.each do |line|
+              backtrace.line(:number => line.number,
+                             :file   => line.file,
+                             :method => line.method)
+            end
+          end
+        end
+        if url ||
+            controller ||
+            action ||
+            !parameters.blank? ||
+            !cgi_data.blank? ||
+            !session_data.blank?
+          notice.request do |request|
+            request.url(url)
+            request.component(controller)
+            request.action(action)
+            unless parameters.nil? || parameters.empty?
+              request.params do |params|
+                xml_vars_for(params, parameters)
+              end
+            end
+            unless session_data.nil? || session_data.empty?
+              request.session do |session|
+                xml_vars_for(session, session_data)
+              end
+            end
+            unless cgi_data.nil? || cgi_data.empty?
+              request.tag!("cgi-data") do |cgi_datum|
+                xml_vars_for(cgi_datum, cgi_data)
+              end
+            end
+          end
+        end
+        notice.tag!("server-environment") do |env|
+          env.tag!("project-root", project_root)
+          env.tag!("environment-name", environment_name)
+          env.tag!("hostname", hostname)
+        end
+      end
+      xml.to_s
+    end
+
+    # Determines if this notice should be ignored
+    def ignore?
+      ignored_class_names.include?(error_class) ||
+        ignore_by_filters.any? {|filter| filter.call(self) }
+    end
+
+    # Allows properties to be accessed using a hash-like syntax
+    #
+    # @example
+    #   notice[:error_message]
+    # @param [String] method The given key for an attribute
+    # @return The attribute value, or self if given +:request+
+    def [](method)
+      case method
+      when :request
+        self
+      else
+        send(method)
+      end
+    end
+
+    private
+
+    attr_writer :exception, :api_key, :backtrace, :error_class, :error_message,
+      :backtrace_filters, :parameters, :params_filters,
+      :environment_filters, :session_data, :project_root, :url, :ignore,
+      :ignore_by_filters, :notifier_name, :notifier_url, :notifier_version,
+      :component, :action, :cgi_data, :environment_name, :hostname
+
+    # Arguments given in the initializer
+    attr_accessor :args
+
+    # Gets a property named +attribute+ of an exception, either from an actual
+    # exception or a hash.
+    #
+    # If an exception is available, #from_exception will be used. Otherwise,
+    # a key named +attribute+ will be used from the #args.
+    #
+    # If no exception or hash key is available, +default+ will be used.
+    def exception_attribute(attribute, default = nil, &block)
+      (exception && from_exception(attribute, &block)) || args[attribute] || default
+    end
+
+    # Gets a property named +attribute+ from an exception.
+    #
+    # If a block is given, it will be used when getting the property from an
+    # exception. The block should accept and exception and return the value for
+    # the property.
+    #
+    # If no block is given, a method with the same name as +attribute+ will be
+    # invoked for the value.
+    def from_exception(attribute)
+      if block_given?
+        yield(exception)
+      else
+        exception.send(attribute)
+      end
+    end
+
+    # Removes non-serializable data from the given attribute.
+    # See #clean_unserializable_data
+    def clean_unserializable_data_from(attribute)
+      self.send(:"#{attribute}=", clean_unserializable_data(send(attribute)))
+    end
+
+    # Removes non-serializable data. Allowed data types are strings, arrays,
+    # and hashes. All other types are converted to strings.
+    # TODO: move this onto Hash
+    def clean_unserializable_data(data, stack = [])
+      return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
+
+      if data.respond_to?(:to_hash)
+        data.to_hash.inject({}) do |result, (key, value)|
+          result.merge(key => clean_unserializable_data(value, stack + [data.object_id]))
+        end
+      elsif data.respond_to?(:to_ary)
+        data.collect do |value|
+          clean_unserializable_data(value, stack + [data.object_id])
+        end
+      else
+        data.to_s
+      end
+    end
+
+    # Replaces the contents of params that match params_filters.
+    # TODO: extract this to a different class
+    def clean_params
+      clean_unserializable_data_from(:parameters)
+      filter(parameters)
+      if cgi_data
+        clean_unserializable_data_from(:cgi_data)
+        filter(cgi_data)
+      end
+      if session_data
+        clean_unserializable_data_from(:session_data)
+        filter(session_data)
+      end
+    end
+
+    def clean_rack_request_data
+      if cgi_data
+        cgi_data.delete("rack.request.form_vars")
+      end
+    end
+
+    def filter(hash)
+      if params_filters
+        hash.each do |key, value|
+          if filter_key?(key)
+            hash[key] = "[FILTERED]"
+          elsif value.respond_to?(:to_hash)
+            filter(hash[key])
+          end
+        end
+      end
+    end
+
+    def filter_key?(key)
+      params_filters.any? do |filter|
+        key.to_s.include?(filter.to_s)
+      end
+    end
+
+    def find_session_data
+      self.session_data = args[:session_data] || args[:session] || rack_session || {}
+      self.session_data = session_data[:data] if session_data[:data]
+    end
+
+    # Converts the mixed class instances and class names into just names
+    # TODO: move this into Configuration or another class
+    def ignored_class_names
+      ignore.collect do |string_or_class|
+        if string_or_class.respond_to?(:name)
+          string_or_class.name
+        else
+          string_or_class
+        end
+      end
+    end
+
+    def xml_vars_for(builder, hash)
+      hash.each do |key, value|
+        if value.respond_to?(:to_hash)
+          builder.var(:key => key){|b| xml_vars_for(b, value.to_hash) }
+        else
+          builder.var(value.to_s, :key => key)
+        end
+      end
+    end
+
+    def rack_env(method)
+      rack_request.send(method) if rack_request
+    end
+
+    def rack_request
+      @rack_request ||= if args[:rack_env]
+        ::Rack::Request.new(args[:rack_env])
+      end
+    end
+
+    def action_dispatch_params
+      args[:rack_env]['action_dispatch.request.parameters'] if args[:rack_env]
+    end
+
+    def rack_session
+      args[:rack_env]['rack.session'] if args[:rack_env]
+    end
+
+    def also_use_rack_params_filters
+      if args[:rack_env]
+        @params_filters ||= []
+        @params_filters += rack_request.env["action_dispatch.parameter_filter"] || []
+      end
+    end
+
+    def local_hostname
+      Socket.gethostname
+    end
+
+  end
+end

data/lib/validation_tracker_client/rails.rb

@@ -0,0 +1,34 @@
+require 'validation_tracker_client'
+require 'validation_tracker_client/rails/controller_methods'
+require 'validation_tracker_client/rails/action_controller_catcher'
+require 'validation_tracker_client/rails/error_lookup'
+require 'validation_tracker_client/rails/javascript_notifier'
+
+module ValidationTrackerClient
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, ValidationTrackerClient::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, ValidationTrackerClient::Rails::ErrorLookup)
+        ActionController::Base.send(:include, ValidationTrackerClient::Rails::ControllerMethods)
+        ActionController::Base.send(:include, ValidationTrackerClient::Rails::JavascriptNotifier)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
+
+      ValidationTrackerClient.configure(true) do |config|
+        config.logger = rails_logger
+        config.environment_name = RAILS_ENV  if defined?(RAILS_ENV)
+        config.project_root     = RAILS_ROOT if defined?(RAILS_ROOT)
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}" if defined?(::Rails::VERSION)
+      end
+    end
+  end
+end
+
+ValidationTrackerClient::Rails.initialize
+

data/lib/validation_tracker_client/rails/controller_methods.rb

@@ -0,0 +1,62 @@
+module ValidationTrackerClient
+  module Rails
+    module ControllerMethods
+      private
+
+      # This method should be used for sending manual notifications while you are still
+      # inside the controller. Otherwise it works like ValidationTrackerClient.notify.
+      def notify_validation_message(hash_or_exception)
+        unless validation_tracker_local_request?
+          ValidationTrackerClient.notify(hash_or_exception, validation_tracker_request_data)
+        end
+      end
+      
+      def validation_tracker_local_request?
+        if defined?(::Rails.application.config)
+          ::Rails.application.config.consider_all_requests_local || request.local?
+        else
+          consider_all_requests_local || local_request?
+        end
+      end
+
+      def validation_tracker_request_data
+        { :parameters       => validation_tracker_filter_if_filtering(params.to_hash),
+          :session_data     => validation_tracker_filter_if_filtering(validation_tracker_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => validation_tracker_request_url,
+          :cgi_data         => validation_tracker_filter_if_filtering(request.env) }
+      end
+
+      def validation_tracker_filter_if_filtering(hash)
+        return hash if ! hash.is_a?(Hash)
+
+        if respond_to?(:filter_parameters)
+          filter_parameters(hash) rescue hash
+        else
+          hash
+        end
+      end
+
+      def validation_tracker_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def validation_tracker_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.fullpath
+        url
+      end
+    end
+  end
+end
+

data/lib/validation_tracker_client/railtie.rb

@@ -0,0 +1,22 @@
+require 'validation_tracker_client'
+require 'rails'
+
+module ValidationTrackerClient
+  class Railtie < Rails::Railtie
+
+    config.after_initialize do
+      ValidationTrackerClient.configure(true) do |config|
+        config.logger           ||= Rails.logger
+        config.environment_name ||= Rails.env
+        config.project_root     ||= Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+
+      if defined?(::ActionController::Base)
+        require 'validation_tracker_client/rails/controller_methods'
+        
+        ::ActionController::Base.send(:include, ValidationTrackerClient::Rails::ControllerMethods)
+      end
+    end
+  end
+end

data/lib/validation_tracker_client/sender.rb

@@ -0,0 +1,76 @@
+module ValidationTrackerClient
+  # Sends out the notice to Validation Tracker
+  class Sender
+
+    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].freeze
+
+    def initialize(options = {})
+      [:proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+        :host, :port, :secure, :http_open_timeout, :http_read_timeout].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Sends the notice data off to Validation Tracker for processing.
+    #
+    # @param [String] data The XML notice to be sent off
+    def send_to_hoptoad(data)
+      logger.debug { "Sending request to #{url.to_s}:\n#{data}" } if logger
+
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+        new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+      http.use_ssl      = secure
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => e
+                   log :error, "Timeout while contacting the Validation Tracker server."
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log :info, "Success: #{response.class}", response
+      else
+        log :error, "Failure: #{response.class}", response
+      end
+
+      if response && response.respond_to?(:body)
+        error_id = response.body.match(%r{<error-id[^>]*>(.*?)</error-id>})
+        error_id[1] if error_id
+      end
+    end
+
+    private
+
+    attr_reader :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+      :host, :port, :secure, :http_open_timeout, :http_read_timeout
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(level, message, response = nil)
+      logger.send level, LOG_PREFIX + message if logger
+      ValidationTrackerClient.report_environment_info
+      ValidationTrackerClient.report_response_body(response.body) if response && response.respond_to?(:body)
+    end
+
+    def logger
+      ValidationTrackerClient.logger
+    end
+
+  end
+end

data/lib/validation_tracker_client/version.rb

@@ -0,0 +1,3 @@
+module ValidationTrackerClient
+  VERSION = "2.4.11"
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'validation_tracker_client/rails'

data/test.rb

@@ -0,0 +1,7 @@
+system 'rake build --trace'
+system 'rake install'
+require 'rubygems'
+require 'debugger'
+gem 'validation_tracker_client'
+
+ValidationTrackerClient.notify('COOL')

data/validation_tracker_client.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/validation_tracker_client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["arun.kumar.arjunan"]
+  gem.email         = ["arun@chronus.com"]
+  gem.description   = %q{Validation Tracker Client}
+  gem.summary       = %q{Validation Tracker Summary}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "validation_tracker_client"
+  gem.require_paths = ["lib"]
+  gem.version       = ValidationTrackerClient::VERSION
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: validation_tracker_client
+version: !ruby/object:Gem::Version
+  version: 2.4.11
+  prerelease: 
+platform: ruby
+authors:
+- arun.kumar.arjunan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-08 00:00:00.000000000 Z
+dependencies: []
+description: Validation Tracker Client
+email:
+- arun@chronus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/validation_tracker_client.rb
+- lib/validation_tracker_client/configuration.rb
+- lib/validation_tracker_client/notice.rb
+- lib/validation_tracker_client/rails.rb
+- lib/validation_tracker_client/rails/controller_methods.rb
+- lib/validation_tracker_client/railtie.rb
+- lib/validation_tracker_client/sender.rb
+- lib/validation_tracker_client/version.rb
+- rails/init.rb
+- test.rb
+- validation_tracker_client.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Validation Tracker Summary
+test_files: []