0
@@ -14,19 +14,32 @@ module God
0
     
0
     self.directory = {}
0
     self.queue = Queue.new
0
-    self.mutex = Mutex.new
0
+    self.mutex = Monitor.new
0
     
0
     def self.start
0
       5.times do
0
         Thread.new do
0
           loop do
0
-            puts 'looping'
0
-            item = self.queue.pop rescue nil
0
-            if item
0
-              puts 'reschedule'
0
-              Timer.queue << TimerEvent.new(item.condition, item.condition.interval)
0
-              
0
-              sleep 0.25 if self.queue.empty?
0
+            begin
0
+              event = self.queue.pop rescue nil
0
+              if event
0
+                self.mutex.synchronize do
0
+                  case event.condition
0
+                    when PollCondition
0
+                      self.handle_poll(event.condition, event.phase)
0
+                    when EventCondition, TriggerCondition
0
+                      self.handle_event(event.condition)
0
+                  end
0
+                end
0
+                
0
+                # Timer.queue << TimerEvent.new(item.condition, item.condition.interval)
0
+                
0
+                sleep 0.25 if self.queue.empty?
0
+              end
0
+            rescue Exception => e
0
+              message = format("Unhandled exception (%s): %s\n%s",
0
+                               e.class, e.message, e.backtrace.join("\n"))
0
+              applog(nil, :fatal, message)
0
             end
0
           end
0
         end
0
@@ -76,18 +89,18 @@ module God
0
     #   +phase+ is the phase of the Watch at the time the condition was scheduled
0
     #
0
     # Returns nothing
0
-    def self.trigger(condition, phase = nil)
0
-      self.queue << [condition, phase]
0
-      
0
-      # self.mutex.synchronize do
0
-      #   case condition
0
-      #     when PollCondition
0
-      #       self.handle_poll(condition, phase)
0
-      #     when EventCondition, TriggerCondition
0
-      #       self.handle_event(condition)
0
-      #   end
0
-      # end
0
-    end
0
+    # def self.trigger(condition, phase = nil)
0
+    #   self.queue << [condition, phase]
0
+    #   
0
+    #   self.mutex.synchronize do
0
+    #     case condition
0
+    #       when PollCondition
0
+    #         self.handle_poll(condition, phase)
0
+    #       when EventCondition, TriggerCondition
0
+    #         self.handle_event(condition)
0
+    #     end
0
+    #   end
0
+    # end
0
     
0
     # private
0
     
0
@@ -98,81 +111,59 @@ module God
0
     #
0
     # Returns nothing
0
     def self.handle_poll(condition, phase)
0
-      # # puts 'reschedule'
0
-      # # Timer.get.schedule(condition)
0
-      # 
0
-      # metric = self.directory[condition]
0
-      # 
0
-      # # it's possible that the timer will trigger an event before it can be cleared
0
-      # # by an exiting metric, in which case it should be ignored
0
-      # return if metric.nil?
0
-      # 
0
-      # Thread.new do
0
-      #   begin
0
-      #     watch = metric.watch
0
-      #     
0
-      #     # watch.mutex.synchronize do
0
-      #       # ensure this condition is still active when we finally get the mutex
0
-      #       if self.directory[condition] && phase == watch.phase
0
-      #         # # run the test
0
-      #         # result = condition.test
0
-      #         # 
0
-      #         # # log
0
-      #         # messages = self.log(watch, metric, condition, result)
0
-      #         # 
0
-      #         # # notify
0
-      #         # if condition.notify && self.trigger?(metric, result)
0
-      #         #   self.notify(condition, messages.last)
0
-      #         # end
0
-      #         # 
0
-      #         # # after-condition
0
-      #         # condition.after
0
-      #         # 
0
-      #         # # get the destination
0
-      #         # dest = 
0
-      #         # if result && condition.transition
0
-      #         #   # condition override
0
-      #         #   condition.transition
0
-      #         # else
0
-      #         #   # regular
0
-      #         #   metric.destination && metric.destination[result]
0
-      #         # end
0
-      #         # 
0
-      #         # # transition or reschedule
0
-      #         # if dest
0
-      #         #   # transition
0
-      #         #   begin
0
-      #         #     watch.move(dest)
0
-      #         #   rescue EventRegistrationFailedError
0
-      #         #     msg = watch.name + ' Event registration failed, moving back to previous state'
0
-      #         #     applog(watch, :info, msg)
0
-      #         #     
0
-      #         #     dest = watch.state
0
-      #         #     retry
0
-      #         #   end
0
-      #         # else
0
-      #         #   # reschedule
0
-      #         #   Timer.get.schedule(condition)
0
-      #         # end
0
-      #         puts 'reschedule'
0
-      #         Timer.get.schedule(condition)
0
-      #       end
0
-      #     # end
0
-      #   rescue Exception => e
0
-      #     message = format("Unhandled exception (%s): %s\n%s",
0
-      #                      e.class, e.message, e.backtrace.join("\n"))
0
-      #     applog(nil, :fatal, message)
0
-      #   end
0
-      # end
0
+      metric = self.directory[condition]
0
       
0
-      # Thread.new do
0
-      #   puts 'reschedule'
0
-      #   Timer.get.schedule(condition)
0
-      # end
0
+      # it's possible that the timer will trigger an event before it can be cleared
0
+      # by an exiting metric, in which case it should be ignored
0
+      return if metric.nil?
0
       
0
-      # Timer.get.schedule(condition)
0
+      watch = metric.watch
0
       
0
-      # Thread.list.each {|t| p t}
0
+      watch.mutex.synchronize do
0
+        # ensure this condition is still active when we finally get the mutex
0
+        if self.directory[condition] && phase == watch.phase
0
+          # run the test
0
+          result = condition.test
0
+          
0
+          # log
0
+          messages = self.log(watch, metric, condition, result)
0
+          
0
+          # notify
0
+          if condition.notify && self.trigger?(metric, result)
0
+            self.notify(condition, messages.last)
0
+          end
0
+          
0
+          # after-condition
0
+          condition.after
0
+          
0
+          # # get the destination
0
+          # dest = 
0
+          # if result && condition.transition
0
+          #   # condition override
0
+          #   condition.transition
0
+          # else
0
+          #   # regular
0
+          #   metric.destination && metric.destination[result]
0
+          # end
0
+          # 
0
+          # # transition or reschedule
0
+          # if dest
0
+          #   # transition
0
+          #   begin
0
+          #     watch.move(dest)
0
+          #   rescue EventRegistrationFailedError
0
+          #     msg = watch.name + ' Event registration failed, moving back to previous state'
0
+          #     applog(watch, :info, msg)
0
+          #     
0
+          #     dest = watch.state
0
+          #     retry
0
+          #   end
0
+          # else
0
+            # reschedule
0
+            Timer.queue << TimerEvent.new(condition, condition.interval)
0
+          # end
0
+        end
0
+      end
0
     end
0
     
0
     # Asynchronously evaluate and handle the given event condition. Handles logging

0
@@ -64,7 +64,7 @@ module God
0
       @templog.send(level, text % [])
0
       @mutex.synchronize do
0
         @capture.puts(@templogio.string) if @capture
0
-        self.logs[watch.name] << [Time.now, @templogio.string] if watch
0
+        self.logs[watch.name] << [] if watch # [Time.now, @templogio.string] if watch
0
       end
0
       
0
       # send to regular logger

0
@@ -1,38 +1,20 @@
0
 module God
0
   
0
-  class Timeline < Array
0
+  class Timeline
0
     # Instantiate a new Timeline
0
     #   +max_size+ is the maximum size to which the timeline should grow
0
     #
0
     # Returns Timeline
0
     def initialize(max_size)
0
-      super()
0
+      @storage = []
0
       @max_size = max_size
0
     end
0
     
0
     # Push a value onto the Timeline
0
     #   +val+ is the value to push
0
-    # 
0
-    # Implementation explanation:
0
-    # A performance optimization appears here to speed up the push time.
0
-    # In essence, the code does this:
0
-    #
0
-    #   def push(val)
0
-    #     super(val)
0
-    #     shift if size > @max_size
0
-    #   end
0
-    #
0
-    # But that's super slow due to the shift, so we resort to reverse! and pop
0
-    # which gives us a 2x speedup with 100 elements and a 6x speedup with 1000
0
-    #
0
-    # Returns Timeline
0
     def push(val)
0
-      if (size + 1) > @max_size
0
-        reverse!
0
-        pop
0
-        reverse!
0
-      end
0
-      super(val)
0
+      @storage.concat(val)
0
+      @storage.shift if @storage.size > @max_size
0
     end
0
     
0
     # Push a value onto the timeline