process_monitoring 1.0.0

data/examples/process_monitoring.rb

@@ -0,0 +1,47 @@
+# Author: Kolman Vornovitsky (kolmanv@gmail.com)
+# This files gives example of how to use process monitoring module.
+
+require 'process_monitoring'
+
+# What are we monitoring?
+# 1) Logs
+require 'log'
+
+# 2) Parameters
+require 'params'
+
+Params.init ARGV
+Params['log_write_to_console'] = true
+
+Log.init
+
+# 3) Custom hash of variables
+variables = ThreadSafeHash::ThreadSafeHash.new
+variables.set('some_variable', 'this is an example :)')
+
+# If you want this example to send emails, set Params['enable_monitoring_emails']=true
+# Before you do that, check the emails parameters at 'monitoring.rb'
+
+# Lets initialize the monitoring task.
+# The command below generates new thread which can be retrieved by 'mon.thread'.
+# The command below starts checking periodically for errors in logs and/or send status update emails
+# to Params['monitoring_email']
+mon = Monitoring::Monitoring.new(variables)
+
+# Lets initialize the monitoring variables HTTP interface (look at localhost:5555).
+# The command below generates new thread which can be retrieved by 'mon_http.thread'.
+mon_http = MonitoringInfo::MonitoringInfo.new(variables)
+
+# Lets connect the monitoring to the log.
+Log.add_consumer(mon)
+
+# Let there is a running process
+number = 1
+loop do
+  number += 1
+  variables.set('number', number)
+  Log.info "number: #{number}"
+  remote_mon_info = MonitoringInfo::MonitoringInfo.get_remote_monitoring_info('localhost', 5555)
+  Log.info "Remote monitoring info (localhost:5555): #{remote_mon_info}" if remote_mon_info
+  sleep(3)
+end

data/lib/process_monitoring.rb

@@ -0,0 +1,6 @@
+require 'process_monitoring/monitoring'
+require 'process_monitoring/monitoring_info'
+require 'process_monitoring/thread_safe_hash'
+
+module ProcessMonitoring
+end

data/lib/process_monitoring/monitoring.rb

@@ -0,0 +1,85 @@
+require 'thread'
+
+require 'log'
+require 'params'
+
+require 'process_monitoring/send_email'
+
+# This module purpose it to alert the user on different behaviour such as no space left
+# or other error cases. The module will send email to the user to notify him on those cases.
+module Monitoring
+  Params.float('monitoring_sleep_time_in_seconds', 10,
+               'Represents the monitoring sleeping time in seconds to check data')
+  Params.float('send_email_duration_4_monitoring_state', 60*60,  # Once per hour.
+               'Represents the duration in seconds to send email monitoring state')
+
+  # Username and Password for gmail account to send monitoting emails.
+  Params.string('gmail_username', nil, 'Backup server gmail username.')
+  Params.string('gmail_password', nil, 'Backup server gmail password.')
+
+  class Monitoring
+    attr_reader :thread
+    def initialize(process_variables)
+      @thread = 'dummy'
+    end
+  end
+=begin
+  class Monitoring < Log::Consumer
+    attr_reader :thread
+    def initialize(process_variables)
+      super(false)
+      @passed_time_dur = 0
+      @process_variables = process_variables
+      @thread = Thread.new do
+        loop do
+          Log.debug3 'Sleeping in process monitoring.'
+          sleep(Params['monitoring_sleep_time_in_seconds'])
+          Log.debug3 'Awake in process monitoring.'
+          @passed_time_dur += Params['monitoring_sleep_time_in_seconds']
+          Log.debug3 'handle_logs in process monitoring.'
+          handle_logs()
+          Log.debug3 'handle_monitoring_state in process monitoring.'
+          handle_monitoring_state()
+          @process_variables.inc('monitoring_loop_count')
+        end
+      end
+      # For debug purposes.
+      @thread.abort_on_exception = true
+    end
+
+    private
+    # To keep thread safe state all methods should be private and executed only from @thread
+    def send_email(subject, body)
+      SendEmail.send_email({
+                               :to => Params['gmail_username'],
+                               :from => Params['gmail_username'],
+                               :password => Params['gmail_password'],
+                               :body => body,
+                               :subject => subject,
+                           })
+    end
+
+    # Override logs consumer handler.
+    def handle_logs
+      while log_msg = @consumer_queue.pop(non_block=true) do
+        send_log_email(log_msg) if Log.is_error(log_msg)
+      end rescue ThreadError  # Rescue when queue is empty.
+    end
+
+    def handle_monitoring_state
+      if @passed_time_dur > Params['send_email_duration_4_monitoring_state']
+        send_email('BBFS Current Monitoring State notification', get_monitoring_state_body())
+        @passed_time_dur = 0
+      end
+    end
+
+    def get_monitoring_state_body
+      # TODO(slava): Implement the following function.
+      # MonitoringInfo::MonitoringInfo.get_html(@process_variables)
+      "server_name: #{@process_variables.get('server_name')}\n" +
+          "num_files_received: #{@process_variables.get('num_files_received')}\n" +
+          "monitoring_loop_count: #{@process_variables.get('monitoring_loop_count')}"
+    end
+  end
+=end
+end

data/lib/process_monitoring/monitoring_info.rb

@@ -0,0 +1,79 @@
+require 'eventmachine'
+require 'json'
+require 'net/http'
+require 'thin'
+require 'sinatra'
+
+require 'params'
+
+# Set up event machine to exit on ctrl+c.
+EventMachine.schedule do
+  trap("INT") do
+    puts "Caught SIGINT"
+    EventMachine.exit # this is useless
+                      # exit # this stops the EventMachine
+  end
+end
+
+# This module export process info to http port, that way the user may access with the
+# browser to the process to see what is happening inside, what is it's state and parameters.
+module MonitoringInfo
+  Params.integer('process_monitoring_web_port', 5555,
+                 'The port from which monitoring data will be served as http.')
+
+  class MonitoringInfo
+    attr_reader :thread
+
+    def initialize(process_variables)
+      @process_variables = process_variables
+      @web_interface = Sinatra.new { get('/') { MonitoringInfo.get_json(process_variables.clone) } }
+      @web_interface.set(:port, Params['process_monitoring_web_port'])
+      @thread = Thread.new do
+        @web_interface.run!
+      end
+    end
+
+    def self.get_json(hash)
+      return '' if !hash.is_a?(Hash)
+
+      entries = []
+      hash.each do |key, value|
+        if value.is_a? String
+          entries << "\"#{key}\": \"#{value}\""
+        else
+          entries << "\"#{key}\": #{value}"
+        end
+      end
+
+      return '{' + entries.join(',') + '}'
+    end
+
+    def self.get_html (hash, opts = {})
+      return if !hash.is_a?(Hash)
+
+      indent_level = opts.fetch(:indent_level) { 0 }
+
+      out = " " * indent_level + "<ul>\n"
+
+      hash.each do |key, value|
+        out += " " * (indent_level + 2) + "<li><strong>#{key}:</strong>"
+
+        if value.is_a?(Hash)
+          out += "\n" + get_html(value, :indent_level => indent_level + 2) + " " * (indent_level + 2) + "</li>\n"
+        else
+          out += " <span>#{value}</span></li>\n"
+        end
+      end
+
+      out += " " * indent_level + "</ul>\n"
+    end
+
+    def self.get_remote_monitoring_info(host, port)
+      begin
+        JSON.parse(Net::HTTP.get(URI("http://#{host}:#{port}/")))
+      rescue Errno::ECONNREFUSED => e
+        ''
+      end
+    end
+  end
+end

data/lib/process_monitoring/send_email.rb

@@ -0,0 +1,40 @@
+require 'net/smtp'
+
+require 'log'
+require 'params'
+
+module SendEmail
+  Params.boolean('enable_monitoring_emails', false, 'Whether to send emails for process monitoring events.')
+
+  #class SendEmail
+  def SendEmail.send_email(opts={})
+    opts[:to]          ||= ''  # Required.
+    opts[:from]        ||= ''  # Required.
+    opts[:from_alias]  ||= 'BBFS Monitoring'
+    opts[:subject]     ||= 'BBFS Notification subject'
+    opts[:body]        ||= 'BBFS Body'
+    opts[:password]    ||= ''  # Required.
+
+    msg = "From: #{opts[:from_alias]} <#{opts[:from]}>\n" \
+          "To: <#{opts[:to]}>\n" \
+          "Subject: #{opts[:subject]}\n" \
+          "#{opts[:body]}"
+
+    email_log_message = "Send actual email: #{Params['enable_monitoring_emails']}.\n" \
+                        "to: #{opts[:to]}\n" \
+                        "msg:#{msg}"
+    if Params['enable_monitoring_emails']
+      Log.debug1(email_log_message)
+      smtp = Net::SMTP.new('smtp.gmail.com', 587)
+      smtp.enable_starttls
+      smtp.start('bbfs.com', opts[:from], opts[:password], :login) do
+        smtp.send_message(msg, opts[:from], opts[:to])
+      end
+    else
+      Log.info(email_log_message)
+    end
+  end
+  #end
+end
+
+

data/lib/process_monitoring/thread_safe_hash.rb

@@ -0,0 +1,39 @@
+# Simple thread safe hash.
+module ThreadSafeHash
+  class ThreadSafeHash
+    def initialize()
+      @hash_data = Hash.new()
+      @mutex = Mutex.new
+    end
+
+    def inc(key)
+      @mutex.synchronize do
+        value = @hash_data[key]
+        if value.nil?
+          @hash_data[key] = 1
+        else
+          @hash_data[key] = value + 1
+        end
+      end
+    end
+
+    def get(key)
+      @mutex.synchronize do
+        @hash_data[key]
+      end
+    end
+
+    def set(key, value)
+      @mutex.synchronize do
+        @hash_data[key] = value
+      end
+    end
+
+    def clone
+      @mutex.synchronize do
+        @hash_data.clone
+      end
+    end
+  end
+end
+

data/lib/process_monitoring/version.rb

@@ -0,0 +1,3 @@
+module ProcessMonitoring
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: process_monitoring
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Gena Petelko, Kolman Vornovitsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: log
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: params
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Holds variable set which is regularly updated and export it to http protocol
+email: bbfsdev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/process_monitoring.rb
+- lib/process_monitoring/thread_safe_hash.rb
+- lib/process_monitoring/monitoring_info.rb
+- lib/process_monitoring/send_email.rb
+- lib/process_monitoring/monitoring.rb
+- lib/process_monitoring/version.rb
+- examples/process_monitoring.rb
+homepage: http://github.com/bbfsdev/bbfs
+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.24
+signing_key: 
+specification_version: 3
+summary: Library to add monitoring for processes.
+test_files:
+- examples/process_monitoring.rb