plugins/CloudWatch/metric_alarms.py

   1 import sys
   2 import os
   3 import re
   4 import datetime
   5 import random
   6 import logging as log
   7 from random import randint
   8 from operator import itemgetter
   9 from connection import Connection
  10
  11 try:
  12     import boto
  13     import boto.ec2
  14     import boto.vpc
  15     import boto.ec2.cloudwatch
  16     import boto.ec2.connection
  17 except:
  18     exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
  19
  20
  21 class MetricAlarm():
  22     """Alarms Functionality Handler -- Cloudwatch """
  23
  24     def config_alarm(self,cloudwatch_conn,alarm_info):
  25         """Configure or Create a new alarm"""
  26
  27         """ Alarm Name to ID Mapping """
  28         alarm_id = alarm_info['alarm_name'] + "_" + alarm_info['resource_id']
  29         if self.is_present(cloudwatch_conn,alarm_id) == True:
  30             alarm_id = None
  31             log.debug ("Alarm already exists, Try updating the alarm using 'update_alarm_configuration()'")
  32         else:
  33             try:
  34                 alarm = boto.ec2.cloudwatch.alarm.MetricAlarm(
  35                     connection = cloudwatch_conn,
  36                     name = alarm_info['alarm_name'] + "_" + alarm_info['resource_id'],
  37                     metric = alarm_info['alarm_metric'],
  38                     namespace = alarm_info['instance_type'],
  39                     statistic = alarm_info['alarm_statistics'],
  40                     comparison = alarm_info['alarm_comparison'],
  41                     threshold = alarm_info['alarm_threshold'],
  42                     period = alarm_info['alarm_period'],
  43                     evaluation_periods = alarm_info['alarm_evaluation_period'],
  44                     unit=alarm_info['alarm_unit'],
  45                     description = alarm_info['alarm_severity'] + ";" + alarm_info['alarm_description'],
  46                     dimensions = {'InstanceId':alarm_info['resource_id']},
  47                     alarm_actions = None,
  48                     ok_actions = None,
  49                     insufficient_data_actions = None)
  50
  51                 """Setting Alarm Actions :
  52                 alarm_actions = ['arn:aws:swf:us-west-2:465479087178:action/actions/AWS_EC2.InstanceId.Stop/1.0']"""
  53
  54                 cloudwatch_conn.put_metric_alarm(alarm)
  55                 log.debug ("Alarm Configured Succesfully")
  56                 print "created"
  57                 print "\n"
  58             except Exception as e:
  59                 log.error("Alarm Configuration Failed: " + str(e))
  60         return alarm_id
  61 #-----------------------------------------------------------------------------------------------------------------------------
  62     def update_alarm(self,cloudwatch_conn,alarm_info):
  63
  64         """Update or reconfigure an alarm"""
  65
  66         """Alarm Name to ID Mapping"""
  67         alarm_id = alarm_info['alarm_name'] + "_" + alarm_info['resource_id']
  68
  69         """Verifying : Alarm exists already"""
  70         if self.is_present(cloudwatch_conn,alarm_id) == False:
  71             alarm_id = None
  72             log.debug("Alarm not found, Try creating the alarm using 'configure_alarm()'")
  73         else:
  74             try:
  75                 alarm = boto.ec2.cloudwatch.alarm.MetricAlarm(
  76                         connection = cloudwatch_conn,
  77                         name = alarm_info['alarm_name'] + "_" + alarm_info['resource_id'],
  78                         metric = alarm_info['alarm_metric'],
  79                         namespace = alarm_info['instance_type'],
  80                         statistic = alarm_info['alarm_statistics'],
  81                         comparison = alarm_info['alarm_comparison'],
  82                         threshold = alarm_info['alarm_threshold'],
  83                         period = alarm_info['alarm_period'],
  84                         evaluation_periods = alarm_info['alarm_evaluation_period'],
  85                         unit=alarm_info['alarm_unit'],
  86                         description = alarm_info['alarm_severity'] + ";" + alarm_info['alarm_description'],
  87                         dimensions = {'InstanceId':alarm_info['resource_id']},
  88                         alarm_actions = None,
  89                         ok_actions = None,
  90                         insufficient_data_actions = None)
  91                 cloudwatch_conn.put_metric_alarm(alarm)
  92                 log.debug("Alarm %s Updated ",alarm.name)
  93                 print "updated"
  94             except Exception as e:
  95                 log.error ("Error in Updating Alarm " + str(e))
  96         return alarm_id
  97 #-----------------------------------------------------------------------------------------------------------------------------
  98     def delete_Alarm(self,cloudwatch_conn,alarm_id):
  99         """Deletes an Alarm with specified alarm_id"""
 100         try:
 101             if self.is_present(cloudwatch_conn,alarm_id) == True:
 102                 deleted_alarm=cloudwatch_conn.delete_alarms(alarm_id)
 103                 return alarm_id
 104             return None
 105         except Exception as e:
 106                 log.error("Alarm Not Deleted: " + str(e))
 107 #-----------------------------------------------------------------------------------------------------------------------------
 108     def alarms_list(self,cloudwatch_conn,instance_id):
 109
 110         """Get a list of alarms that are present on a particular VM instance"""
 111         try:
 112             log.debug("Getting Alarm list for %s",instance_id)
 113             alarm_dict = dict()
 114             alarm_list = []
 115             alarms = cloudwatch_conn.describe_alarms()
 116             itr = 0
 117             for alarm in alarms:
 118                 if str(alarm.dimensions['InstanceId']).split("'")[1] == instance_id:
 119                     alarm_list.insert(itr,str(alarm.name))
 120                     itr += 1
 121             alarm_dict['alarm_names'] = alarm_list
 122             alarm_dict['resource_id'] = instance_id
 123             return alarm_dict
 124         except Exception as e:
 125                 log.error("Error in Getting List : %s",str(e))
 126 #-----------------------------------------------------------------------------------------------------------------------------
 127     def alarm_details(self,cloudwatch_conn,alarm_name):
 128
 129         """Get an individual alarm details specified by alarm_name"""
 130         try:
 131             alarms_details=cloudwatch_conn.describe_alarm_history()
 132             alarm_details_dict = dict()
 133
 134             for itr in range (len(alarms_details)):
 135                 if alarms_details[itr].name == alarm_name and 'created' in alarms_details[itr].summary :#name, timestamp, summary
 136                     status = alarms_details[itr].summary.split()
 137                     alarms = cloudwatch_conn.describe_alarms()
 138                     for alarm in alarms:
 139                         if alarm.name == alarm_name:
 140                             alarm_details_dict['alarm_id'] = alarm_name
 141                             alarm_details_dict['resource_id'] = str(alarm.dimensions['InstanceId']).split("'")[1]
 142                             alarm_details_dict['severity'] = str(alarm.description)
 143                             alarm_details_dict['start_date_time'] = str(alarms_details[x].timestamp)
 144
 145                             return alarm_details_dict
 146
 147         except Exception as e:
 148                 log.error("Error getting alarm details: %s",str(e))
 149 #-----------------------------------------------------------------------------------------------------------------------------
 150     def metrics_data(self,cloudwatch_conn,metric_name,instance_id,period,metric_unit):
 151
 152         """Getting Metrics Stats for an Hour. Time interval can be modified using Timedelta value"""
 153         metric_data= dict()
 154         metric_stats=cloudwatch_conn.get_metric_statistics(period, datetime.datetime.utcnow() - datetime.timedelta(seconds=3600),
 155                             datetime.datetime.utcnow(),metric_name,'AWS/EC2', 'Maximum',
 156                             dimensions={'InstanceId':instance_id}, unit=metric_unit)
 157
 158         for itr in range (len(metric_stats)):
 159             metric_data['metric_name'] = metric_name
 160             metric_data['Resource_id'] = instance_id
 161             metric_data['Unit']            = metric_stats[itr]['Unit']
 162             metric_data['Timestamp']   = metric_stats[itr]['Timestamp']
 163         return metric_data
 164
 165 #-----------------------------------------------------------------------------------------------------------------------------
 166     def is_present(self,cloudwatch_conn,alarm_name):
 167         """Finding Alarm exists or not"""
 168         try:
 169             alarms = cloudwatch_conn.describe_alarms()
 170             for alarm in alarms:
 171                 if alarm.name == alarm_name:
 172                     return True
 173             return False
 174         except Exception as e:
 175                 log.error("Error Finding Alarm",str(e))
 176 #-----------------------------------------------------------------------------------------------------------------------------