validation_rage 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby
+  - rbx-19mode

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michael Bumann
+
+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,80 @@
+# ValidationRage
+
+ValidationRage is a gem to capture validation errors from your Ruby application.
+The goal is to identify usability issues in your application that are caused by validations.
+
+Imaging a form with several field validations. ValidationRage makes it super easy to get information on what fields the users experience validation errors (and might leave because of that).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'validation_rage'
+
+
+## Usage
+
+By default ValidationRage will hook into ActiveRecord::Base and log all validation errors to your Rails log.
+
+ValidationRage comes with an rails engine to configure your application. "config" in the following examples refer to Rails.application.config
+You can configure if you want to hook into your models or controllers.
+
+### Logging on model level ###
+
+You can hook ValidationRage into your classes that are ActiveModel::Validation compatible.
+
+example configuration: 
+
+    config.validation_rage.attach_to = [User, Account, Session] # hook into the User, Account, Session classes and attach an after_validation callback to track invalid records
+  
+### Logging on controller level ###
+
+The problem with attaching ValidationRage to your models is that you do not have any information about the context: where did the error happen? what parameters causes the error? 
+That's why you can hook ValidationRage into your controllers. ValidationRage will add an after_callback checking your instance variables for errors.
+
+example configuration:
+
+    config.validation_rage.attach_to = ["users#create", "session#create"] # hook into the Users and Session controler create actions
+    
+    # using * to match any action or any controller:
+    
+    config.validation_rage.attach_to = ["*#create"] # hook into every create action. - this is done by adding the after_filter to the ApplicationController
+    config.validation_rage.attach_to = ["users#*"] # hook into every action in the users controler.
+    
+example configuration with both model and controller level logging:
+
+    config.validation_rage.attach_to = ["users#create", Company] # hook into the create action of the UsersController AND the Company model
+
+
+### Using different notifiers ###
+
+ValidationRage uses ActiveSupport::Notifications to publish a notification message when an validation error happened. This makes it super easy to write a listener to those events and process the validation error information.
+This gem comes with different Notifiers and since the integrate with ActiveSupport::Notifiers you can use several notifiers at the same time and write your own notifer.
+
+#### LogNotifier ####
+
+uses the logger to log your validation errors. 
+
+configuration:
+
+    config.validation_rage.notifier["Log"] = {:log_level => :warn, :logger => Logger.new("log/validations.log")}
+
+#### UdpNotifier ####
+
+send the errors as JSON to a UDP server server
+
+configuration:
+
+    config.validation_rage.notifier["Udp"] = {:host => "localhost", :port => 3333}
+
+
+#### ValidationRageNotifer ####
+
+send the errors to the ValidationRage Application which gives you a nice accessible interface to analyze your data.
+Signup at validationrage.com to get your API key
+
+configuration:
+
+    config.validation_rage.notifier["ValidationRage"] = {:api_key => "<YOUR API KEY>"}
+    
+

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+task :default => :test

data/lib/validation_rage/base_notifier.rb

@@ -0,0 +1,18 @@
+module ValidationRage
+  class BaseNotifier
+    class NotImplementedError < StandardError; end
+    
+    def initialize(args={})
+    end
+    def call(event_name, payload)
+      raise NotImplementedError.new("your notifer must implement a call(event_name, payload) method")
+    end
+    def subscribe!
+      ActiveSupport::Notifications.subscribe(/validation_rage:.*/, self)
+    end
+    
+    def data_present?(payload)
+      payload.values.first && !payload.values.first.empty?
+    end
+  end
+end

data/lib/validation_rage/controller_extension.rb

@@ -0,0 +1,28 @@
+module ValidationRage
+  module ControllerExtension
+
+    def notify_validation_rage
+      objects_with_errors = self.instance_variables.collect {|var_name| instance_variable_get(var_name) if validation_rage_errors_present?(var_name) }.compact
+      objects_with_errors.each do |o|
+        ActiveSupport::Notifications.publish("validation_rage:errors", {o.class.name => o.errors.to_hash, :context => self.validation_rage_context })
+      end
+    end
+
+    def validation_rage_errors_present?(var_name)
+      return false if var_name.to_s =~ /^@_/ # ignore variable names marked with "_" - those are by convention internal only
+      obj = instance_variable_get(var_name)
+      obj.respond_to?(:errors) && !obj.errors.empty?
+    end
+
+    def validation_rage_context
+      {
+        :controller   => params[:controller],
+        :action       => params[:action],
+        :request_path => request.path,
+        :params       => request.filtered_parameters,
+        :request_uuid => request.uuid,
+        :referrer     => request.referrer
+      }
+    end
+  end
+end

data/lib/validation_rage/fnord_metric_notifier.rb

@@ -0,0 +1,34 @@
+require "fnordmetric"
+module ValidationRage
+  class FnordMetricNotifier < BaseNotifier
+    attr_accessor :fnord
+
+    def initialize(args={})
+      self.fnord = FnordMetric::API.new(:redis_url => args[:redis_url])
+    end
+
+    # I guess this is toooooo sloooow but anyhow let's play with it
+    def call(event_name, payload)
+      return unless data_present?(payload)
+
+      # global validation error event
+      self.fnord.event({
+        :_type => event_name,
+        :payload => payload
+      })
+      # class level validation error event
+      self.fnord.event({
+        :_type => "validation_rage_error.#{payload.keys.first.to_s.downcase}",
+        :payload => payload.values.first.keys
+      })
+      # two events are enough for now
+      ## attribute level validation error event
+      #payload.values.first.each do |attribute, error_messages|
+      #  self.fnord.event({
+      #    :_type => "validation_rage_error.#{payload.keys.first.to_s.downcase}.#{attribute}",
+      #    :payload => error_messages
+      #  })
+      #end
+    end
+  end
+end

data/lib/validation_rage/log_notifier.rb

@@ -0,0 +1,14 @@
+module ValidationRage
+  class LogNotifier < BaseNotifier
+    attr_accessor :logger, :log_level
+    def initialize(args)
+      self.logger     = args[:logger]
+      self.log_level  = args[:log_level]  || :warn
+    end
+    # TODO: optimize log format
+    def call(event_name, payload)
+      return if payload.values.first && payload.values.first.empty?
+      self.logger.send(self.log_level, "#{event_name} #{payload}")
+    end
+  end
+end

data/lib/validation_rage/model_extension.rb

@@ -0,0 +1,12 @@
+module ValidationRage
+  module ModelExtension
+
+    def self.included(base)
+      base.after_validation(:notify_validation_rage)
+    end
+
+    def notify_validation_rage(context = {})
+      ActiveSupport::Notifications.publish("validation_rage:errors", {self.class.name => self.errors.to_hash, :context => context})
+    end
+  end
+end

data/lib/validation_rage/rails.rb

@@ -0,0 +1,43 @@
+module ValidationRage
+  class Engine < ::Rails::Engine
+
+    config.validation_rage = ActiveSupport::OrderedOptions.new
+
+    config.validation_rage.attach_to = [] 
+    config.validation_rage.attach_to = [ActiveRecord::Base] if defined?(ActiveRecord::Base) # really?!
+
+    config.validation_rage.notifier = {"Log" => {:log_level => :warn, :logger => nil}} # defaults to log everything to the logger
+
+    initializer "validation_rage.configure_subscribers" do |app|
+      # TODO move this into a testable setup method and refactor! -
+
+      if app.config.validation_rage # if validation rage is enabled
+        app.config.validation_rage.notifier.each do |name, options|
+          options[:logger] ||= Rails.logger
+          ValidationRage.const_get("#{name}Notifier").new(options).subscribe! # initialize the notifier and subscribe to the active suppot notification messages
+        end
+
+        # attach validation rage integration extensions to controllers (with after filter) or models (with after_validation filters) 
+        controllers = {}
+        app.config.validation_rage.attach_to.each do |klass_or_action|
+          # if its a string we collect the controller and actions to later add a after_filter
+          if klass_or_action.is_a?(String)
+            controller, action = klass_or_action.split("#")
+            controllers[controller] ||= []
+            controllers[controller] << action
+          else
+            klass.send(:include, ValidationRage::ModelExtension)
+          end
+        end
+        # now addingt the after filter to controllers
+        controllers.each do |controller, actions|
+          controller = "Application" if controller == "*"
+          controller_class = "#{controller}Controller".classify.constantize rescue next # just ignore errors for now
+          controller_class.send(:include, ValidationRage::ControllerExtension)
+          options = {:only => actions} unless actions.any? {|a| a == "*"}
+          controller_class.send(:after_filter, :notify_validation_rage, options)
+        end
+      end
+    end
+  end
+end

data/lib/validation_rage/udp_notifier.rb

@@ -0,0 +1,17 @@
+require "socket"
+module ValidationRage
+  class UdpNotifier < BaseNotifier
+
+    attr_accessor :socket, :host, :port
+    def initialize(args)
+      self.socket = UDPSocket.new
+      self.host = args[:host]
+      self.port = args[:port]
+    end
+
+    def call(event_name, payload)
+      self.socket.send(payload.to_json, 0, self.host, self.port)
+    end
+  end
+
+end

data/lib/validation_rage/validation_rage_notifier.rb

@@ -0,0 +1,19 @@
+require "socket"
+module ValidationRage
+  class ValidationRageNotifier < BaseNotifier
+
+    attr_accessor :socket, :host, :port, :api_key
+    def initialize(args)
+      self.socket = UDPSocket.new
+      self.host = "localhost"
+      self.port = 33333
+      self.api_key = args[:api_key]
+    end
+
+    def call(event_name, payload)
+      data = {:api_key => self.api_key, :payload => payload}
+      self.socket.send(data.to_json, 0, self.host, self.port)
+    end
+  end
+
+end

data/lib/validation_rage/version.rb

@@ -0,0 +1,3 @@
+module ValidationRage
+  VERSION = "0.0.1"
+end

data/lib/validation_rage.rb

@@ -0,0 +1,13 @@
+require "validation_rage/version"
+require "active_support/notifications"
+require 'validation_rage/rails' if defined?(Rails)
+require "json"
+module ValidationRage
+  autoload :BaseNotifier, "validation_rage/base_notifier"
+  autoload :LogNotifier, "validation_rage/log_notifier"
+  autoload :UdpNotifier, "validation_rage/udp_notifier"
+  autoload :ValidationRageNotifier, "validation_rage/validation_rage_notifier"
+  autoload :FnordMetricNotifier, "validation_rage/fnord_metric_notifier"
+  autoload :ModelExtension, "validation_rage/model_extension"
+  autoload :ControllerExtension, "validation_rage/controller_extension"
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bundler/setup'
+Bundler.require
+require 'minitest/autorun'
+require 'minitest/mock'
+require "mocha"
+
+require 'validation_rage'
+
+
+class MockModel
+  def self.after_validation(method)
+    @@after_validation_method = method
+  end
+  def self.after_validation_method
+    @@after_validation_method
+  end
+  def self.name
+    "MockClass"
+  end
+end

data/test/validation_rage/base_notifier_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+class ValidationRage::BaseNotifierTest < MiniTest::Unit::TestCase
+  
+  def test_call_raises_a_not_implemented_error
+    assert_raises(ValidationRage::BaseNotifier::NotImplementedError) { ValidationRage::BaseNotifier.new.call("event", {}) }
+  end
+  
+  def test_subscribe_to_validation_rage_events
+    notifier = ValidationRage::BaseNotifier.new
+    ActiveSupport::Notifications.expects(:subscribe).with(/validation_rage:.*/, notifier)
+    notifier.subscribe!
+  end
+  
+  def test_data_present
+    notifier = ValidationRage::BaseNotifier.new
+    assert notifier.data_present?("klass" => {:error => :message})
+    assert !notifier.data_present?("klass" => {})
+    assert !notifier.data_present?({})
+  end
+end

data/test/validation_rage/controller_extension_test.rb

@@ -0,0 +1,60 @@
+require "test_helper"
+
+# TODO: guess this test could be written nicer
+class MockController
+  def request
+    OpenStruct.new(:filtered_parameters => ["filtered", "params"], :path => "/mock/path", :uuid => "uuid", :referrer => "referrer")    
+  end
+  def params
+    {:controller => "Mock", :action => "create"}
+  end
+  def initialize(records={})
+    records.each do |name,record|
+      instance_variable_set("@#{name}", record)
+    end
+  end
+end
+class ValidationRage::ControllerExtensionTest < MiniTest::Unit::TestCase
+
+  def setup
+    @klass = Class.new(MockController)
+    @klass.send(:include, ValidationRage::ControllerExtension)
+  end
+
+  def test_errors_present
+    assert !@klass.new(:var => "not responding to errors").validation_rage_errors_present?(:"@var")
+    assert !@klass.new(:var => mock(:errors => [])).validation_rage_errors_present?(:"@var")
+    assert !@klass.new(:_var => "internal only vars should be ignored").validation_rage_errors_present?(:"@_var")
+    assert @klass.new(:var => mock(:errors => ["not empty"])).validation_rage_errors_present?(:"@var")
+  end
+
+  def test_validation_rage_context
+    assert_equal({
+      :controller   => "Mock",
+      :action       => "create",
+      :request_path => "/mock/path",
+      :params       => ["filtered","params"], 
+      :request_uuid => "uuid", 
+      :referrer     => "referrer"
+    }, @klass.new.validation_rage_context)
+  end
+  
+  def test_notify_validation_rage
+    record = MockModel.new
+    record.expects(:errors).at_least_once.returns(mock(:"empty?"=>false, :to_hash=>{:errors => :hash}))
+    controller_instance = @klass.new(:record => record, :foo => :bar)
+    ActiveSupport::Notifications.expects(:publish).with("validation_rage:errors", {
+      "MockClass" => {:errors => :hash}, 
+      :context => {
+        :controller   => "Mock", 
+        :action       => "create",
+        :request_path => "/mock/path",
+        :params       => ["filtered","params"],
+        :request_uuid => "uuid",
+        :referrer     => "referrer"
+      }
+    })
+    controller_instance.notify_validation_rage
+  end
+
+end

data/test/validation_rage/log_notifier_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class ValidationRage::LogNotifierTest < MiniTest::Unit::TestCase
+  
+
+  def test_defaul_log_level
+    assert_equal :warn, ValidationRage::LogNotifier.new({}).log_level
+  end
+  def test_log_validation_errors_to_logger
+    payload = {"Class" => {:name => ["missing"]}}
+    mocked_logger = mock()
+    mocked_logger.expects(:info).with("event_name #{payload.inspect}")
+    log_notifier = ValidationRage::LogNotifier.new(:logger => mocked_logger, :log_level => :info)
+    log_notifier.call("event_name", payload)
+  end
+
+  def test_ignore_empty_errors
+    mocked_logger = mock()
+    mocked_logger.expects(:warn).never
+    notifier = ValidationRage::LogNotifier.new(:logger => mocked_logger)
+    notifier.call("event_name", "Class" => {})
+  end
+end

data/test/validation_rage/model_extension_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+# TODO: guess this test could be written nicer
+class ValidationRage::ModelExtensionTest < MiniTest::Unit::TestCase
+  
+  def setup
+    @klass = Class.new(MockModel)
+    @klass.send(:include, ValidationRage::ModelExtension)
+  end
+
+  def test_register_after_validation_callback
+    assert_equal :notify_validation_rage, @klass.after_validation_method
+    assert @klass.new.respond_to?(:notify_validation_rage)
+  end
+  
+  def test_publish_active_support_notification
+    instance = @klass.new
+    instance.expects(:errors).returns(mock(:to_hash=>{:errors => :hash}))
+    ActiveSupport::Notifications.expects(:publish).with("validation_rage:errors", {"MockClass" => {:errors => :hash}, :context => {}})
+    instance.notify_validation_rage
+  end
+  
+  def test_passing_a_context_hash_to_notification_call
+    instance = @klass.new
+    instance.expects(:errors).returns(mock(:to_hash=>{:errors => :hash}))
+    ActiveSupport::Notifications.expects(:publish).with("validation_rage:errors", {"MockClass" => {:errors => :hash}, :context => {:controller => "Users", :action => "edit"}})
+    instance.notify_validation_rage({:controller => "Users", :action => "edit"})
+  end
+end

data/test/validation_rage/udp_notifier_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+require "socket"
+class ValidationRage::UdpNotifierTest < MiniTest::Unit::TestCase
+
+  def test_connect_to_socket
+    UDPSocket.expects(:new).returns("socket")
+    notifier = ValidationRage::UdpNotifier.new(:host => "localhost", :port => 33333)
+    assert_equal "socket", notifier.socket
+    assert_equal "localhost", notifier.host
+    assert_equal 33333, notifier.port
+  end
+
+  def test_send_json_encoded_payload_through_socket
+    notifier = ValidationRage::UdpNotifier.new(:host => "host", :port => "port")
+    payload = {"Class" => {:error => :message}}
+    socket = mock()
+    socket.expects(:send).with(payload.to_json,0, "host", "port")
+    notifier.expects(:socket).returns(socket)
+    notifier.call("event_name", payload)
+  end
+end

data/validation_rage.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/validation_rage/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Michael Bumann"]
+  gem.email         = ["michael@railslove.com"]
+  gem.description   = %q{log active model validation errors to get better insights in the usability of your forms}
+  gem.summary       = %q{log active model validation errors to get better insights in the usability of your forms}
+  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_rage"
+  gem.require_paths = ["lib"]
+  gem.version       = ValidationRage::VERSION
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'mocha'
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'json'
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: validation_rage
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Michael Bumann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2156416240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156416240
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &2156459260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156459260
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2156470080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156470080
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2156465740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156465740
+description: log active model validation errors to get better insights in the usability
+  of your forms
+email:
+- michael@railslove.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/validation_rage.rb
+- lib/validation_rage/base_notifier.rb
+- lib/validation_rage/controller_extension.rb
+- lib/validation_rage/fnord_metric_notifier.rb
+- lib/validation_rage/log_notifier.rb
+- lib/validation_rage/model_extension.rb
+- lib/validation_rage/rails.rb
+- lib/validation_rage/udp_notifier.rb
+- lib/validation_rage/validation_rage_notifier.rb
+- lib/validation_rage/version.rb
+- test/test_helper.rb
+- test/validation_rage/base_notifier_test.rb
+- test/validation_rage/controller_extension_test.rb
+- test/validation_rage/log_notifier_test.rb
+- test/validation_rage/model_extension_test.rb
+- test/validation_rage/udp_notifier_test.rb
+- validation_rage.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: log active model validation errors to get better insights in the usability
+  of your forms
+test_files:
+- test/test_helper.rb
+- test/validation_rage/base_notifier_test.rb
+- test/validation_rage/controller_extension_test.rb
+- test/validation_rage/log_notifier_test.rb
+- test/validation_rage/model_extension_test.rb
+- test/validation_rage/udp_notifier_test.rb
+has_rdoc: