whoops 0.4.0 → 0.5.0

data/app/controllers/event_groups_controller.rb

@@ -1,5 +1,4 @@
-class EventGroupsController < ApplicationController
-  layout 'whoops'
+class EventGroupsController < WhoopsController
   before_filter :update_event_group_filter
   helper_method :event_group_filter
   
@@ -25,11 +24,13 @@ class EventGroupsController < ApplicationController
   end
   
   def event_group_filter
-    session[:event_group_filter] ||= Whoops::Filter.new
+    session[:event_group_filter] ||= new_whoops_filter
   end
   
   def event_group_filter=(filter)
-    session[:event_group_filter] = Whoops::Filter.new_from_params(filter)
+    filter = Whoops::Filter.new_from_params(filter)
+    filter.authorized_service_lookup = authorized_service_lookup
+    session[:event_group_filter] = filter
   end
 
   def update

data/app/controllers/events_controller.rb

@@ -1,8 +1,6 @@
-class EventsController < ApplicationController
-  layout 'whoops'
-  
+class EventsController < WhoopsController  
   def index
-    @event_group = Whoops::EventGroup.find(params[:whoops_event_group_id])
+    @event_group = Whoops::EventGroup.where(new_whoops_filter.to_query_document).find(params[:whoops_event_group_id])
     
     events_base = @event_group.events
     unless params[:query].blank?
@@ -22,7 +20,7 @@ class EventsController < ApplicationController
   
   # TODO break this out into a more metal-y controller
   def create
-    Whoops::Event.record(params[:event])
+    Whoops::NewEvent.new(params[:event]).record!
     render :status => 200, :nothing => true
   end
 end

data/app/controllers/notification_subscriptions_controller.rb

@@ -1,6 +1,4 @@
-class NotificationSubscriptionsController < ApplicationController
-  layout 'whoops'
-
+class NotificationSubscriptionsController < WhoopsController
   def index
     @notification_subscription = Whoops::NotificationSubscription.new
     @notification_subscription.build_filter

data/app/controllers/whoops_controller.rb

@@ -0,0 +1,17 @@
+class WhoopsController < ApplicationController
+  layout 'whoops'
+
+  private
+  helper_method :authorized_service_lookup
+  
+  # overwrite this to implement rules for hiding services
+  def authorized_service_lookup
+    @authorized_service_lookup ||= Whoops::AuthorizedServiceLookup.new(nil)
+  end
+
+  def new_whoops_filter
+    filter = Whoops::Filter.new
+    filter.authorized_service_lookup = authorized_service_lookup
+    filter
+  end
+end

data/app/helpers/event_groups_helper.rb

@@ -11,7 +11,7 @@ module EventGroupsHelper
     # group services by root, eg "sv1.web" and "sv1.resque" are in the
     # same sub array
     previous_service_root = ""
-    Whoops::EventGroup.services.to_a.sort.each { |service|
+    authorized_service_lookup.filter_authorized(Whoops::EventGroup.services).to_a.sort.each { |service|
       service_root = (/(.*?)\./ =~ service && $~[1]) || service
       if service_root == previous_service_root
         @filter_field_allowed_values["service"].last << service

data/app/models/whoops/authorized_service_lookup.rb

@@ -0,0 +1,45 @@
+# This class is meant to be overwritten in host applications
+#
+# Authorized Service Lookups interact with filters to limit the
+# services which a user is allowed to see. This allows host
+# applications to more easily implement authorization.
+#
+# For example, if your Whoops installation is used by many different
+# teams, but you don't want the teams to see each others' data, you
+# could create a mapping between the team members' email addresses and
+# the services they're allowed to see.
+#
+# Since filters are used when viewing events or sending notifications,
+# the authorized service lookup allows you to modify the filters to
+# prevent the unauthorized services from being seen
+class Whoops::AuthorizedServiceLookup
+
+  # @param key the value used to look up authorized services
+  def initialize(key)
+    @key = key
+  end
+
+  # if there are services given, then show all services
+  # however, if we're looking at authorized services, then "all
+  # services" means "all authorized services"
+  #
+  # if there is a filter on service then only allow authorized
+  # services
+  # 
+  # one thing to note is that if both services and authorized_services
+  # are blank, then no filter will be applied to service at all
+  def filter_authorized(services)
+    matches = services.select{ |s| service_authorized?(s) }
+    matches.empty? ? authorized_services : matches
+  end
+
+  # Overwrite this in your subclasses if you want to implement
+  # authorized services
+  def authorized_services
+    []
+  end
+
+  def service_authorized?(service)
+    authorized_services.blank? || /^(#{authorized_services.join("|")})/ =~ service
+  end
+end

data/app/models/whoops/event.rb

@@ -15,18 +15,6 @@ class Whoops::Event
   
   before_save :set_keywords, :sanitize_details
   
-  def self.record(params)
-    params = params.with_indifferent_access
-    
-    event_group_params                    = params.slice(*Whoops::EventGroup.field_names)
-    event_group_params[:last_recorded_at] = params[:event_time]
-    event_group_params
-    event_group = Whoops::EventGroup.handle_new_event(event_group_params)
-    
-    event_params = params.slice(*Whoops::Event.field_names)
-    event_group.events.create(event_params)
-  end 
-  
   def self.search(query)
     conditions = Whoops::MongoidSearchParser.new(query).conditions
     where(conditions)

data/app/models/whoops/event_group.rb

@@ -17,28 +17,6 @@ class Whoops::EventGroup
   field :last_recorded_at, :type => DateTime
   field :archived, :type => Boolean, :default => false
   field :event_count, :type => Integer, :default => 0
-
-  class << self
-    def handle_new_event(params)
-      identifying_params = params.slice(*Whoops::EventGroup.identifying_fields)
-      event_group = Whoops::EventGroup.first(:conditions => identifying_params)
-      
-      if event_group
-        event_group.attributes = params
-      else
-        event_group = Whoops::EventGroup.new(params)
-      end
-      
-      if event_group.valid?
-        event_group.send_notifications
-        event_group.archived = false
-        event_group.event_count += 1
-        event_group.save
-      end
-
-      event_group
-    end
-  end
   
   has_many :events, :class_name => "Whoops::Event"
   
@@ -52,14 +30,4 @@ class Whoops::EventGroup
   def self.services
     all.distinct(:service).sort
   end
-
-  def should_send_notifications?
-    (archived || new_record) && Rails.application.config.whoops_sender
-  end
-  
-  def send_notifications
-    return unless should_send_notifications?
-    matcher = Whoops::NotificationSubscription::Matcher.new(self)
-    Whoops::NotificationMailer.event_notification(self, matcher.matching_emails).deliver unless matcher.matching_emails.empty?
-  end
 end

data/app/models/whoops/filter.rb

@@ -1,4 +1,6 @@
 class Whoops::Filter
+  attr_accessor :authorized_service_lookup
+  
   include Mongoid::Document
   include FieldNames
 
@@ -13,7 +15,7 @@ class Whoops::Filter
   def to_query_document
     doc = attributes.except(:_id, "_id", :_type, "_type").delete_if{|k, v| v.blank?}
     # match all services under namespace. ie, if "app" given, match "app.web", "app.backend" etc
-    doc["service"] = doc["service"].collect{ |d| /^#{d}/ } if doc["service"]
+    doc["service"] = service.collect{ |d| /^#{d}/ } unless service.blank?
     doc.inject({}) do |hash, current|
       hash[current.first.to_sym.in] = current.last unless current.last.empty?
       hash
@@ -34,6 +36,24 @@ class Whoops::Filter
     update_attributes(self.class.clean_params(params))
   end
 
+  def service
+    if authorized_services_provided?
+      authorized_services
+    else
+      attributes["service"]
+    end
+  end
+
+  private
+
+  def authorized_services_provided?
+    authorized_service_lookup
+  end
+  
+  def authorized_services
+    authorized_service_lookup.filter_authorized(attributes["service"].to_a)
+  end
+
   class << self
     def new_from_params(params)
       if params

data/app/models/whoops/new_event.rb

@@ -0,0 +1,55 @@
+# Receives new event params and processes them
+class Whoops::NewEvent
+  def initialize(params)
+    @params = params.with_indifferent_access
+  end
+
+  # both records and sends notifications
+  def record!
+    find_or_build_event_group
+    update_event_group_attributes
+    send_notifications_for_event_group
+    
+    @event_group.archived = false
+    @event_group.save
+    @event_group.events.create(event_params)
+    @event_group
+  end
+
+  private
+
+  def find_or_build_event_group
+    @event_group = Whoops::EventGroup.first(:conditions => event_group_identifying_fields) || Whoops::EventGroup.new(event_group_params)
+  end
+
+  def update_event_group_attributes
+    if @event_group.valid?
+      @event_group.attributes = event_group_params
+      @event_group.last_recorded_at = Time.now
+      @event_group.event_count += 1
+    end
+  end
+
+  def should_send_notifications?
+    @event_group.valid? && (@event_group.archived || @event_group.new_record) && Rails.application.config.whoops_sender
+  end
+
+  def send_notifications_for_event_group
+    return unless should_send_notifications?
+    matcher = Whoops::NotificationSubscription::Matcher.new(@event_group)
+    Whoops::NotificationMailer.event_notification(@event_group, matcher.matching_emails).deliver unless matcher.matching_emails.empty?
+  end
+
+  # TODO does it make sense to have a separate params object?
+  def event_group_params
+    @params.slice(*Whoops::EventGroup.field_names)
+  end
+
+  def event_group_identifying_fields
+    @params.slice(*Whoops::EventGroup.identifying_fields)
+  end
+
+  def event_params
+    @params.slice(*Whoops::Event.field_names)
+  end
+end

data/app/models/whoops/notification_subscription.rb

@@ -21,7 +21,10 @@ class Whoops::NotificationSubscription
     end
     
     def matching_emails
-      Whoops::NotificationSubscription.all.select{ |ns| ns.filter.matches_event_group?(self.event_group) }.collect(&:email)
+      Whoops::NotificationSubscription.all.select do |ns|
+        lookup = Whoops::AuthorizedServiceLookup.new(ns.email)
+        ns.filter.matches_event_group?(self.event_group)
+      end.collect(&:email)
     end
   end
 end

data/app/views/filters/_filters.html.haml

@@ -1,4 +1,4 @@
-- filter_field_allowed_values.each do |field_name, allowed_value_groups|
+- %w{service environment event_type}.map{|k| [k, filter_field_allowed_values[k]]}.each do |field_name, allowed_value_groups|
   %h4= field_name
   %ul.filter-selects.inputs-list
     - allowed_value_groups.each do |allowed_values|
@@ -9,4 +9,4 @@
             = allowed_value
       - unless allowed_values == allowed_value_groups.last
         %li.divider
-          %hr
+          %hr

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: whoops
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Daniel Higginbotham
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-28 00:00:00 Z
+date: 2012-12-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rails
@@ -187,17 +187,19 @@ files:
 - app/controllers/event_groups_controller.rb
 - app/controllers/events_controller.rb
 - app/controllers/notification_subscriptions_controller.rb
+- app/controllers/whoops_controller.rb
 - app/helpers/event_groups_helper.rb
 - app/helpers/events_helper.rb
 - app/helpers/filters_helper.rb
 - app/helpers/notifications_helper.rb
 - app/lib/field_names.rb
 - app/mailers/whoops/notification_mailer.rb
+- app/models/whoops/authorized_service_lookup.rb
 - app/models/whoops/event.rb
 - app/models/whoops/event_group.rb
 - app/models/whoops/filter.rb
 - app/models/whoops/mongoid_search_parser.rb
-- app/models/whoops/notification_rule.rb
+- app/models/whoops/new_event.rb
 - app/models/whoops/notification_subscription.rb
 - app/views/event_groups/_list.html.haml
 - app/views/event_groups/index.html.haml

data/app/models/whoops/notification_rule.rb

@@ -1,63 +0,0 @@
-class Whoops::NotificationRule
-  include Mongoid::Document
-  
-  field :email, :type => String
-  field :matchers, :type => Array
-
-  validates_presence_of :email
-
-  # This might come in handy in the future?
-  # class << self.fields["matchers"]
-  #   def set(object)
-  #     object = object.split("\n").collect{ |m| m.strip } if object.is_a?(String)
-  #     object
-  #   end
-  # end
-  
-  before_save :downcase_email
-  
-  def downcase_email
-    self.email.downcase!
-  end
-  
-  def matchers=(matchers)
-    write_attribute(:matchers, split_matchers(matchers).sort)
-  end
-
-  def add_matchers(new_matchers)
-    split = split_matchers(new_matchers)
-    write_attribute(:matchers, (self.matchers | split).sort)
-    self.save
-  end
-
-  def split_matchers(new_matchers)
-    new_matchers.split("\n").collect{ |m| m.strip }
-  end
-
-  def self.add_rules(params)
-    params[:email] = params[:email].downcase
-    if rule = first(:conditions => {:email => params[:email]})
-      rule.add_matchers(params[:matchers])
-    else
-      create(params)
-    end
-  end
-  
-  class Matcher
-    attr_accessor :event_group
-    
-    # @param [ Whoops::EventGroup ]
-    def initialize(event_group)
-      self.event_group = event_group
-    end
-    
-    def matching_emails
-      matches.collect{|m| m.email}.uniq
-    end
-    
-    def matches
-      service_matches = event_group.service.split(".").inject([]){|collection, part| collection << [collection.last, part].compact.join(".")}.join("|")
-      @matches ||= Whoops::NotificationRule.where(:matchers => /^((#{service_matches})\S*$|(#{service_matches}).*#{event_group.environment})/)
-    end
-  end
-end