rrd-grapher 1.0.0

data/lib/rrd-grapher/assets/javascripts/classes/graph_definition.coffee

@@ -0,0 +1,216 @@
+
+class window.GraphController extends Backbone.View
+  initialize: ->
+    @pages = @options.pages
+    
+
+# a page group multiple graph definitions
+class window.GraphPage
+  constructor: (@container, @panel_container, @host) ->
+    @graphs = []
+    @autorefresh_timer = null
+    
+    @autorefresh_checkbox = $("#autorefresh", @panel_container)
+    @linked_zoom_checkbox = $("#linkedzoom", @panel_container)
+    @date_select          = $("#dateselect", @panel_container)
+    
+    @interval = 15*60
+    
+    # 60s
+    @offset = 60 * 1000
+  
+  addGraph: (class_name, args...) ->
+    g = new window[class_name](@container, @host, args...)
+    g.init()
+    g.bind "dblclick", =>
+      @set_simple_interval( @interval )
+      # disable autorefresh
+      @set_autorefresh(null)
+      
+    g.bind "plotselection", (from, to) =>
+      @set_autorefresh(null)
+      if @linked_zoom_checkbox.attr("checked")
+        @set_interval(from, to)
+      
+    @graphs.push( g )
+  
+  set_simple_interval: (interval) ->
+    @interval = interval
+    
+    # clear the date select
+    @date_select.val("")
+    
+    # getTime return a timestamp in UTC so no
+    # conversion is required
+    to = (new Date().getTime()) - @offset
+    to = to / 1000
+    from = to - @interval
+    
+    @set_interval(from, to)
+  
+  set_interval: (from, to) ->
+    $.each @graphs, (i, g) ->
+      g.set_interval(from, to)
+      g.update_graph()
+  
+  # set time to null to disable
+  set_autorefresh: (time) ->
+    # start by killing the timer if any
+    if @autorefresh_timer
+      window.clearInterval( @autorefresh_timer )
+      @autorefresh_timer = null
+    
+    # and create a new one if asked
+    if time
+      @autorefresh_checkbox.attr("checked", true)
+      @autorefresh_timer = window.setInterval ( => @set_simple_interval(@interval) ), time
+    else
+      @autorefresh_checkbox.attr("checked", false)
+  
+  refresh: ->
+      @set_simple_interval(@interval)
+
+  
+# define a graph with its series
+class window.GraphDefinition
+  constructor: (@host, @container, @title, formatters, ymin) ->
+    _.extend(this, Backbone.Events);
+    
+    if ymin
+      # create an array with the same size as the formatters
+      ymin = $.makeArray(ymin)
+      if ymin.length == 1
+        limits = $.map formatters, -> [[0, ymin[0]]]
+      else if ymin.length == 2
+        limits = $.map ymin, (val)-> [[0, val]]
+        
+      
+        
+    else
+      limits = $.map formatters, -> [[0, 0]]
+    
+    @graph = new Graph
+      "title"             : @title
+      "parent_container"  : @container
+      "formatters"        : formatters
+      "limits"            : limits
+    
+    @graph.bind "dblclick", => @trigger("dblclick")
+    @graph.bind "plotselection", (from, to) => @trigger("plotselection", from, to)
+    
+  init: ->
+    @graph.create()
+  
+  set_interval: (from, to) ->
+    @graph.set_interval(from, to)
+  
+  update_graph: ->
+    @graph.update_graph()
+
+
+
+class window.NTPGraph extends GraphDefinition
+  constructor: (container, host, @remote_host, ymin = null) ->
+    super(host, container, "NTP", [ Format.delay, Format.identity ], ymin)
+    
+    # @remote_host2 = @remote_host.replace(/\./g, '-')
+    @graph.addSerie("#{@host}/ntpd/time_offset-#{@remote_host}", "seconds", "Offset remote")
+    @graph.addSerie("#{@host}/ntpd/time_offset-loop", "seconds", "Offset local")
+    
+    @graph.addSerie("#{@host}/ntpd/delay-#{@remote_host}", "seconds", "Delay remote")
+    
+    @graph.addSerie("#{@host}/ntpd/time_dispersion-#{@remote_host}", "seconds", "Dispertion remote")
+    @graph.addSerie("#{@host}/ntpd/time_dispersion-LOCAL", "seconds", "Dispertion local")
+
+
+class window.CPUGraph extends GraphDefinition
+  constructor: (container, host, @cpu_index, ymin = null) ->
+    super(host, container, "CPU #{@cpu_index}", [ Format.percent, Format.prcent ], ymin)
+    @graph.addSerie("#{@host}/cpu-#{@cpu_index}/cpu-user",      'value', 'User')
+    @graph.addSerie("#{@host}/cpu-#{@cpu_index}/cpu-system",    'value', 'System')
+    @graph.addSerie("#{@host}/cpu-#{@cpu_index}/cpu-interrupt", 'value', 'Interrupt')
+
+
+class window.DFGraph extends GraphDefinition
+  constructor: (container, host, @location, ymin = null) ->
+    super(host, container, "Disk use (#{@location})", [ Format.size, Format.size ], ymin)
+    @graph.addSerie("#{@host}/df/df-#{@location}",  'used', 'Used')
+    @graph.addSerie("#{@host}/df/df-#{@location}",  'free', 'Free')
+
+class window.PingGraph extends GraphDefinition
+  constructor: (container, host, @label, @destination, ymin = null) ->
+    super(host, container, "Ping #{@label}", [ Format.delay, Format.identity ], ymin)
+    
+    @graph.addSerie("#{@host}/ping/ping-#{@destination}", 'ping', 'Latency')
+    @graph.addSerie("#{@host}/ping/ping_stddev-#{@destination}", 'value', 'stddev')
+    @graph.addSerie("#{@host}/ping/ping_droprate-#{@destination}", 'value', 'Loss', 2)
+    
+
+class window.NetworkGraph extends GraphDefinition
+  constructor: (container, host, @interface, ymin = null) ->
+    super(host, container, "Network Traffic (#{interface})", [ Format.size, Format.size ], ymin)
+
+    @graph.addSerie("#{@host}/interface/if_octets-#{@interface}", "rx", "(#{@interface}) Bytes Received")
+    @graph.addSerie("#{@host}/interface/if_octets-#{@interface}", "tx", "(#{@interface}) Bytes Sent")
+
+
+class window.MemoryGraph extends GraphDefinition
+  constructor: (container, host, os, ymin = null) ->
+    super(host, container, "Memory", [ Format.size, Format.size ], ymin)
+    
+    if os == "osx"
+      @graph.addSerie("#{@host}/memory/memory-active",    "value", "Active")
+      @graph.addSerie("#{@host}/memory/memory-free",      "value", "Free")
+      @graph.addSerie("#{@host}/memory/memory-inactive",  "value", "Inactive")
+      @graph.addSerie("#{@host}/memory/memory-wired",     "value", "Wired")
+    else if os == "freebsd"
+      @graph.addSerie("#{@host}/memory/memory-active",    "value", "Active")
+      @graph.addSerie("#{@host}/memory/memory-cache",     "value", "Cached")
+      @graph.addSerie("#{@host}/memory/memory-free",      "value", "Free")
+      @graph.addSerie("#{@host}/memory/memory-inactive",  "value", "Inactive")
+      @graph.addSerie("#{@host}/memory/memory-wired",     "value", "Wired")
+    else if os == "linux"
+      @graph.addSerie("#{@host}/memory/memory-buffered",  "value", "Buffered")
+      @graph.addSerie("#{@host}/memory/memory-cached",    "value", "Caached")
+      @graph.addSerie("#{@host}/memory/memory-free",      "value", "Free")
+      @graph.addSerie("#{@host}/memory/memory-used",      "value", "Used")
+
+
+class window.LoadGraph extends GraphDefinition
+  constructor: (container, host, ymin = null) ->
+    super(host, container, "CPU Load", [ Format.identity, Format.identity ], ymin)
+
+    @graph.addSerie("#{@host}/load/load",    "shortterm", "Load (1min)")
+    @graph.addSerie("#{@host}/load/load",    "midterm", "Load (5min)")
+    @graph.addSerie("#{@host}/load/load",    "longterm", "Load (15min)")
+
+class window.CollectdNetworkStats extends GraphDefinition
+  constructor: (container, host, can_send = true, ymin = null) ->
+    super(host, container, "Network Stats (collectd)", [ Format.identity, Format.identity ], ymin)
+    
+    @graph.addSerie("#{@host}/network/queue_length", "value", "Queue length")
+    
+    @graph.addSerie("#{@host}/network/total_values-dispatch-accepted", "value", "Values dipatch accepted", 2)
+    @graph.addSerie("#{@host}/network/total_values-dispatch-rejected", "value", "Values dipatch rejected", 2)
+    
+    if can_send
+      @graph.addSerie("#{@host}/network/total_values-send-accepted", "value", "Values send accepted", 2)
+      @graph.addSerie("#{@host}/network/total_values-send-rejected", "value", "Values send rejected", 2)
+    
+
+class window.CollectdNetworkBandwidth extends GraphDefinition
+  constructor: (container, host, can_send = true, ymin = null) ->
+    super(host, container, "Network Usage (collectd)", [ Format.size, Format.identity ], ymin)
+
+    @graph.addSerie("#{@host}/network/if_octets", "rx", "Bytes Received")
+    @graph.addSerie("#{@host}/network/if_octets", "tx", "Bytes Sent") if can_send
+    
+    @graph.addSerie("#{@host}/network/if_packets", "rx", "Packets Received", 2)
+    @graph.addSerie("#{@host}/network/if_packets", "tx", "Packets Sent", 2) if can_send
+
+class window.MonitoringDriftGraph extends GraphDefinition
+  constructor: (container, host, ymin = null) ->
+    super(host, container, "Clock drift", [ Format.delay, Format.delay ], ymin)
+    
+    @graph.addSerie("#{@host}/monitoring/gauge-clock_drift", "value", "Drift")
+    

data/lib/rrd-grapher/assets/javascripts/classes/serie.coffee

@@ -0,0 +1,13 @@
+
+class window.Serie extends StaticLine
+  constructor: (@rrd_path, @ds_name, @legend, @yaxis = 1, @formatter = Format.identity, @rra = null) ->
+    super(null, legend, yaxis, formatter)
+    @static = false
+  
+  get_definition: () ->
+    {
+      data: @data,
+      label: @legend,
+      yaxis: @yaxis,
+      color: @color
+    }

data/lib/rrd-grapher/assets/javascripts/classes/size.coffee

@@ -0,0 +1,5 @@
+
+window.Size = 
+  kilobyte: 1024,
+  megabyte: 1024*1024,
+  gigabyte: 1024*1024*1024

data/lib/rrd-grapher/assets/javascripts/classes/static_line.coffee

@@ -0,0 +1,44 @@
+
+class window.StaticLine
+  constructor: (@yvalue, @legend, @yaxis = 1, @formatter = Format.identity) ->
+    @enabled = true
+    @data = []
+    @static = true
+    @color = 'black'
+  
+  set_data: (data) ->
+    @data = []
+    
+    $.each data, (t, v) =>
+      @data.push( [Time.server_to_client(t), v] )
+    
+  get_data: ->
+    @data
+  
+  format: (v) ->
+    @formatter(v)
+  
+  set_legend_color: (element) ->
+    tr = $(element).parent()
+    tr.toggleClass('transparent', not @enabled)
+  
+  set_enabled: (new_state) ->
+    @enabled = new_state
+  
+  toggle_enabled: () ->
+    this.set_enabled(not @enabled)
+  
+  get_definition: (from, to) ->
+    @data = [
+        [Time.server_to_client(from), @yvalue],
+        [Time.server_to_client(to), @yvalue]
+      ]
+    
+    {
+      data: @data,
+      label: @legend,
+      yaxis: @yaxis,
+      color: @color
+    }
+
+

data/lib/rrd-grapher/assets/javascripts/classes/time.coffee

@@ -0,0 +1,17 @@
+
+window.Time =
+  # getTimezoneOffset() returns local offset in hours
+  tz_offset: 60 * -( new Date() ).getTimezoneOffset()
+  
+  local_to_utc: (timestamp) ->
+    parseInt(timestamp, 10) - Time.tz_offset
+  
+  utc_to_local: (timestamp) ->
+    parseInt(timestamp, 10) + Time.tz_offset
+  
+  server_to_client: (timestamp) ->
+    @utc_to_local(timestamp) * 1000
+  
+  client_to_server: (timestamp) ->
+    Math.floor( @local_to_utc(timestamp / 1000) )
+  

data/lib/rrd-grapher/notifier/alarm_manager.rb

@@ -0,0 +1,190 @@
+
+require 'fiber_pool'
+
+require File.expand_path('../structures', __FILE__)
+require File.expand_path('../alarms', __FILE__)
+require File.expand_path('../alarm_trigger', __FILE__)
+require File.expand_path('../default_user_handler', __FILE__)
+require File.expand_path('../collectdrb', __FILE__)
+
+module RRDNotifier
+    
+  ##
+  # Trigger/Stop the alarms based on user configuration
+  # 
+  class AlarmManager
+    
+    attr_reader :fiber_pool
+    
+    ##
+    # Create a new AlertManager object
+    # 
+    # @param [Hash] opts options
+    # @option opts [Module,Object] notification_manager The object
+    #   used when a new notification is triggered/stopped
+    # @option opts [FiberPool] fiber_pool Fiber pool to use.
+    # @option opts [String] :send_monitoring_to if present we can send
+    #   our own stats to this <host>:<port>
+    # 
+    def initialize(opts = {})
+      @notification_handler = opts.delete(:notification_handler) || DefaultNotificationHandler
+      send_monitoring_to = opts.delete(:send_monitoring_to)
+      if send_monitoring_to
+        @send_monitoring_to_host, @send_monitoring_to_port = send_monitoring_to.split(':')
+        # to just data to collectd
+        @collectd_socket = EM::open_datagram_socket('127.0.0.1', nil)
+      end
+      
+      unless valid_notification_handler?(@notification_handler)
+        raise "notification_handler #{@notification_handler} invalid, some callbacks are missing !"
+      end
+      
+      @fiber_pool = opts.delete(:fiber_pool) || FiberPool.new(10)
+      @triggers = []
+      @active_alarms = {}
+      @last_updates = {}
+    end
+    
+    ##
+    # Check that the object respond to the required
+    # methods.
+    # 
+    # @param [Object] obj the handler
+    # 
+    def valid_notification_handler?(obj)
+      obj.respond_to?(:dispatch_notification) &&
+      obj.respond_to?(:alarm_started) &&
+      obj.respond_to?(:alarm_stopped)
+    end
+    
+    ##
+    # Register a new alarm.
+    # @see AlarmTrigger::initialize
+    # 
+    def register_alarm(*args)
+      @triggers << AlarmTrigger.new(self, *args)
+    end
+    
+    ##
+    # Called by the Notifier when an event is successfully extracted
+    # from a collectd packet.
+    # 
+    # @param [Packet] p packet received
+    # 
+    def packet_received(p)
+      @fiber_pool.spawn do
+        if p.data?
+          trigger_notifications(p)
+          @last_updates[p.measure_id] = Time.now
+        else
+          @notification_handler.dispatch_notification(p)
+        end
+      end
+    end
+    
+    ##
+    # Send a counter to collectd.
+    # 
+    def send_gauge(host, interval, plugin, plugin_instance, type, type_instance, value)
+      data = Collectd.new(host, interval)
+      data.start()
+      data.gauge(plugin, plugin_instance, type, type_instance, value)
+      
+      @collectd_socket.send_datagram(data.to_s, @send_monitoring_to_host, @send_monitoring_to_port)
+    end
+    
+    
+    ##
+    # Called all the triggers matching this packet
+    # to see if one or more wants to start/stop alarms.
+    # 
+    # @param [Packet] p the packet
+    # 
+    def trigger_notifications(p)
+      @triggers.each{|t| t.check_alarms(p) }
+    end
+    
+    
+  # Alarm api, used by the triggers
+    
+    ##
+    # Raise an alarm.
+    # 
+    # @param [String] measure_id counter ID
+    # @param [Alarm] alarm An alarm object
+    # 
+    def raise_alarm(measure_id, alarm)
+      @notification_handler.alarm_started(alarm)
+      (@active_alarms[measure_id] ||= []) << alarm
+    end
+    
+    ##
+    # Used by triggers to query the time of the last update for
+    # this measure.
+    # 
+    # @param [String] measure_id ID Representing this particular
+    #   counter
+    # 
+    def last_update_for(measure_id)
+      @last_updates[measure_id]
+    end
+    
+    def active_alarms_for(measure_id)
+      @active_alarms[measure_id] ||= []
+    end
+    
+    ##
+    # Stop an alarm.
+    # 
+    # @param [String] measure_id counter ID
+    # @param [Alarm] alarm An alarm object
+    # 
+    def stop_specific_alarm(measure_id, alarm)
+      active_alarms_for(measure_id).delete(alarm)
+      @notification_handler.alarm_stopped(alarm)
+    end
+    
+    ##
+    # Stop an alarm matching specified params.
+    # 
+    # @param [String] measure_id counter ID
+    # @param [Class] alarm_class The alarm class
+    # @param [Array] args these will be given to
+    #   Alarm::is_same? so the alarm can tell us if
+    #   it matchs.
+    # 
+    # @note This method is just a wrapper around
+    #   active_alarm? and stop_specific_alarm.
+    # 
+    def stop_alarm(measure_id, alarm_class, *args)
+      # check if we have an active alarm
+      alarm = active_alarm?(measure_id, alarm_class, *args)
+      if alarm
+        stop_specific_alarm(measure_id, alarm)
+      end
+    end
+    
+    
+    ##
+    # Return the active alarm matching given
+    # parameters.
+    # 
+    # @param [String] measure_id counter ID
+    # @param [Class] alarm_class The alarm class
+    # @param [Array] args these will be given to
+    #   Alarm::is_same? so the alarm can tell us if
+    #   it matchs.
+    # 
+    def active_alarm?(measure_id, alarm_class, *args)      
+      # fetch active alarms
+      active_alarms = active_alarms_for(measure_id)
+      
+      # check if we have an active alarm
+      active_alarms.detect do |al|
+        al.is_a?(alarm_class) && al.is_same?(*args)
+      end
+    end
+    
+  end
+  
+end

data/lib/rrd-grapher/notifier/alarm_trigger.rb

@@ -0,0 +1,187 @@
+
+require File.expand_path('../structures', __FILE__)
+require File.expand_path('../alarms', __FILE__)
+
+module RRDNotifier
+  ##
+  # Represents the conditions to raise an alarm.
+  # 
+  class AlarmTrigger
+    ##
+    # Create a new AlarmTrigger object.
+    # 
+    # @param [AlertManager] manager The manager
+    #   (used to raise/stop alarms and query informations)
+    # @param [String, nil] host the hostname (nil: any host)
+    # @param [String] plugin plugin name
+    #   ex: something (any plugin_instance matched)
+    #   ex: something/inst (match both plugin and plugin_instance)
+    # @param [String] type type name (see plugin for format)
+    # @param [Hash] opts Alarm option
+    # @option opts [Number] min minimal allowed value
+    # @option opts [Number] max maximum allowed value
+    # @option opts [Number] monitor_presence raise an
+    #   alarm if data is missing for x seconds
+    # @option opts [Boolean] monitor_drift Ensure the clock
+    #   of the host is not drifting too far from our clock
+    #   (default: false)
+    # @option opts [Integer] index for multi-values counters this
+    #   parameter allow you to select what you want to monitor
+    #   (default: 0)
+    # 
+    def initialize(manager, host, plugin, type, opts = {})
+      @host = self.class.load_param(host)
+      @plugin, @plugin_instance = self.class.load_param(plugin)
+      @type, @type_instance = self.class.load_param(type)
+    
+      @manager = manager
+      
+      @index = opts.delete(:index) || 0
+      @min = opts.delete(:min)
+      @max = opts.delete(:max)
+      @monitor_drift = opts.has_key?(:monitor_drift) ? opts.delete(:monitor_drift) : false
+      @monitor_presence = opts.has_key?(:monitor_presence) ? opts.delete(:monitor_presence) : false
+    
+      raise "Unknown arguments: #{opts.inspect}" unless opts.empty?
+    
+      @timers_register = {}
+    end
+  
+    ##
+    # Split if arg contains a "/" and
+    # return nil if a "*" is found.
+    # 
+    # @param [String] str source string
+    # @return [Array] result
+    # 
+    def self.load_param(str)
+      raise "nil is not a valid value" unless str
+    
+      ret = str.split("/").map! do |s|
+        (s == '*') ? nil : s
+      end
+    
+      (ret.size == 1) ? ret[0] : ret
+    end
+  
+    ##
+    # Checks if this packet is interesting for the
+    # trigger.
+    # 
+    # @param [Packet] p the packet
+    # @return [Boolean] true if the packet is interesting
+    # 
+    def match?(p)
+      (@host.nil? || (@host == p.host)) &&
+      (@plugin.nil? || (@plugin == p.plugin)) &&
+      (@plugin_instance.nil? || (@plugin_instance == p.plugin_instance)) &&
+      (@type.nil? || (@type == p.type)) &&
+      (@type_instance.nil? || (@type_instance == p.type_instance))
+    end
+  
+
+    def inspect
+      "#{@host}-#{@plugin}/#{@plugin_instance}-#{@type}/#{@type_instance}"
+    end
+
+    ##
+    # Called by the manager when a packet is received.
+    # 
+    # @param [Packet] p the packet
+    # 
+    def check_alarms(p)
+      # if the packet is not intersting for me, stop here
+      unless match?(p)
+        return
+      end
+      
+      if @index >= p.values.size
+        puts "index #{@index} was given but only #{p.values.size} found, check disabled"
+        return
+      end
+      
+      value = p.value(@index)
+      
+      check_alarm_high(p, value)
+      check_alarm_low(p, value)
+      check_alarm_presence(p, value)
+      check_alarm_drift(p, value)
+    end
+    
+    def check_alarm_high(p, value)
+      return unless @max
+      
+      if value > @max
+        unless @manager.active_alarm?(p.measure_id, AlarmTooHigh, @max)
+          @manager.raise_alarm( p.measure_id, AlarmTooHigh.new(p, @max) )
+        end
+      else
+        @manager.stop_alarm(p.measure_id, AlarmTooHigh, @max)
+      end
+    end
+    
+    def check_alarm_low(p, value)
+      return unless @min
+      
+      if value < @min
+        unless @manager.active_alarm?(p.measure_id, AlarmTooLow, @min)
+          @manager.raise_alarm( p.measure_id, AlarmTooLow.new(p, @min) )
+        end
+      else
+        @manager.stop_alarm(p.measure_id, AlarmTooLow, @min)
+      end
+    end
+    
+    
+    def check_alarm_drift(p, value)
+      return unless @monitor_drift
+      now = Time.now
+      
+      drift = (now - p.time).to_f.abs
+      # convert the time to ms before sending it
+      @manager.send_gauge(p.host, p.interval, 'monitoring', nil, 'gauge', 'clock_drift', drift * 1000)
+      
+      # check the absolute value of the difference between
+      # current server time and time included in the collectd
+      # packet.
+      if drift > @monitor_drift
+        unless @manager.active_alarm?(p.measure_id, AlarmClockDrift, @monitor_drift)
+          @manager.raise_alarm( p.measure_id, AlarmClockDrift.new(p, @monitor_drift) )
+        end
+      else
+        @manager.stop_alarm(p.measure_id, AlarmClockDrift, @monitor_drift)
+      end
+    end
+    
+    
+    def check_alarm_presence(p, value)
+      return unless @monitor_presence
+      
+      # stop any already active alarm
+      last_update = @manager.last_update_for(p.measure_id)
+      @manager.stop_alarm(p.measure_id, AlarmMissingData, @monitor_presence, last_update)
+    
+      # reset any active timer
+      timer_id = @timers_register[p.measure_id]
+      EM::cancel_timer(timer_id) if timer_id
+    
+      # and create a new one
+      @timers_register[p.measure_id] = EM::add_timer(@monitor_presence) do
+        presence_timeout(p)
+      end
+    end
+  
+    ##
+    # Raise a presence alarm.
+    # 
+    # @param [Packet] p the data point
+    # 
+    def presence_timeout(p)
+      @manager.fiber_pool.spawn do
+        last_update = @manager.last_update_for(p.measure_id)
+        @manager.raise_alarm( p.measure_id, AlarmMissingData.new(p, @monitor_presence, last_update) )
+      end
+    end
+  
+  end
+end