modify the cat

cat-consumer/src/main/java/com/dianping/cat/consumer/heartbeat/HeartbeatAnalyzer.java

@@ -90,7 +90,7 @@ public class HeartbeatAnalyzer extends AbstractMessageAnalyzer<HeartbeatReport>
 		try {
 			info = new com.dianping.cat.status.model.transform.DefaultDomParser().parse(xml);
 		} catch (Exception e) {
-			Cat.logError(e);
+			m_logger.error(e.getMessage(), e);
 			Cat.getProducer().logEvent("HearbeatAnalyzer", "ErrorXml", "Error", xml);
 			return null;
 		}

cat-core/src/main/java/com/dianping/cat/storage/dump/LocalMessageBucketManager.java

@@ -342,7 +342,9 @@ public class LocalMessageBucketManager extends ContainerHolder implements Messag
 	class OldMessageMover implements Task {
 		@Override
 		public void run() {
-			while (true) {
+			boolean active = true;
+			
+			while (active) {
 				try {
 					moveOldMessages();
 				} catch (Throwable e) {
@@ -351,7 +353,7 @@ public class LocalMessageBucketManager extends ContainerHolder implements Messag
 				try {
 					Thread.sleep(2 * 60 * 1000L);
 				} catch (InterruptedException e) {
-					// ignore
+					active = false;
 				}
 			}
 		}

cat-home/pom.xml

@@ -71,7 +71,7 @@
 			<version>1.1.8</version>
 		</dependency>
 		<dependency>
-			<groupId>freemarker</groupId>
+			<groupId>org.freemarker</groupId>
 			<artifactId>freemarker</artifactId>
 			<version>2.3.9</version>
 		</dependency>

cat-home/src/main/java/com/dianping/cat/CatHomeModule.java

@@ -11,10 +11,11 @@ import com.dianping.cat.message.spi.internal.DefaultMessageHandler;
 import com.dianping.cat.report.task.DailyTaskProducer;
 import com.dianping.cat.report.task.DefaultTaskConsumer;
 import com.dianping.cat.report.task.monthreport.MonthReportBuilderTask;
-import com.dianping.cat.system.alarm.DefaultAlarmCreator;
-import com.dianping.cat.system.alarm.ExceptionAlarmTask;
-import com.dianping.cat.system.alarm.exception.listener.ExceptionAlertListener;
-import com.dianping.cat.system.alarm.exception.listener.ExceptionDataListener;
+import com.dianping.cat.system.alarm.AlarmRuleCreator;
+import com.dianping.cat.system.alarm.AlarmTask;
+import com.dianping.cat.system.alarm.threshold.listener.ExceptionDataListener;
+import com.dianping.cat.system.alarm.threshold.listener.ServiceDataListener;
+import com.dianping.cat.system.alarm.threshold.listener.ThresholdAlertListener;
 import com.dianping.cat.system.event.EventListenerRegistry;
 import com.dianping.cat.system.notify.ScheduledMailTask;
 import com.site.helper.Threads;
@@ -43,19 +44,23 @@ public class CatHomeModule extends AbstractModule {
 			Threads.forGroup("Cat").start(monthReportTask);
 		}
 
-		//executeAlarmModule(ctx, serverConfigManager);
+		executeAlarmModule(ctx);
 	}
 
-	private void executeAlarmModule(ModuleContext ctx, ServerConfigManager serverConfigManager) throws Exception {
+	private void executeAlarmModule(ModuleContext ctx) throws Exception {
+		ServerConfigManager serverConfigManager = ctx.lookup(ServerConfigManager.class);
+
 		EventListenerRegistry registry = ctx.lookup(EventListenerRegistry.class);
 		ExceptionDataListener exceptionDataListener = ctx.lookup(ExceptionDataListener.class);
-		ExceptionAlertListener exceptionAlertListener = ctx.lookup(ExceptionAlertListener.class);
+		ServiceDataListener serviceDataListener = ctx.lookup(ServiceDataListener.class);
+		ThresholdAlertListener thresholdAlertListener = ctx.lookup(ThresholdAlertListener.class);
 
 		registry.register(exceptionDataListener);
-		registry.register(exceptionAlertListener);
+		registry.register(serviceDataListener);
+		registry.register(thresholdAlertListener);
 
-		ExceptionAlarmTask exceptionAlarmTask = ctx.lookup(ExceptionAlarmTask.class);
-		DefaultAlarmCreator alarmCreatorTask = ctx.lookup(DefaultAlarmCreator.class);
+		AlarmTask exceptionAlarmTask = ctx.lookup(AlarmTask.class);
+		AlarmRuleCreator alarmCreatorTask = ctx.lookup(AlarmRuleCreator.class);
 		ScheduledMailTask scheduledTask = ctx.lookup(ScheduledMailTask.class);
 
 		if (serverConfigManager.isJobMachine()) {

cat-home/src/main/java/com/dianping/cat/build/AlarmComponentConfigurator.java

@@ -9,10 +9,15 @@ import com.dianping.cat.home.dal.alarm.MailRecordDao;
 import com.dianping.cat.home.dal.alarm.ScheduledReportDao;
 import com.dianping.cat.report.page.model.spi.ModelService;
 import com.dianping.cat.report.service.DailyReportService;
-import com.dianping.cat.system.alarm.DefaultAlarmCreator;
-import com.dianping.cat.system.alarm.ExceptionAlarmTask;
-import com.dianping.cat.system.alarm.exception.listener.ExceptionAlertListener;
-import com.dianping.cat.system.alarm.exception.listener.ExceptionDataListener;
+import com.dianping.cat.system.alarm.AlarmRuleCreator;
+import com.dianping.cat.system.alarm.AlarmTask;
+import com.dianping.cat.system.alarm.alert.AlertManager;
+import com.dianping.cat.system.alarm.connector.Connector;
+import com.dianping.cat.system.alarm.connector.impl.ThresholdConnector;
+import com.dianping.cat.system.alarm.threshold.ThresholdRuleManager;
+import com.dianping.cat.system.alarm.threshold.listener.ServiceDataListener;
+import com.dianping.cat.system.alarm.threshold.listener.ThresholdAlertListener;
+import com.dianping.cat.system.alarm.threshold.listener.ExceptionDataListener;
 import com.dianping.cat.system.event.DefaultEventDispatcher;
 import com.dianping.cat.system.event.DefaultEventListenerRegistry;
 import com.dianping.cat.system.event.EventDispatcher;
@@ -20,6 +25,7 @@ import com.dianping.cat.system.event.EventListenerRegistry;
 import com.dianping.cat.system.notify.ReportRender;
 import com.dianping.cat.system.notify.ReportRenderImpl;
 import com.dianping.cat.system.notify.ScheduledMailTask;
+import com.dianping.cat.system.page.alarm.RuleManager;
 import com.dianping.cat.system.page.alarm.ScheduledManager;
 import com.dianping.cat.system.tool.MailSMS;
 import com.dianping.cat.system.tool.MailSMSImpl;
@@ -32,7 +38,7 @@ public class AlarmComponentConfigurator extends AbstractResourceConfigurator {
 	public List<Component> defineComponents() {
 		List<Component> all = new ArrayList<Component>();
 
-		all.add(C(DefaultAlarmCreator.class)//
+		all.add(C(AlarmRuleCreator.class)//
 		      .req(AlarmRuleDao.class, AlarmTemplateDao.class, ScheduledReportDao.class)//
 		      .req(ModelService.class, "event"));
 
@@ -50,14 +56,24 @@ public class AlarmComponentConfigurator extends AbstractResourceConfigurator {
 		all.add(C(EventDispatcher.class, DefaultEventDispatcher.class)//
 		      .req(EventListenerRegistry.class));
 
-		all.add(C(ExceptionAlertListener.class).//
-		      req(EventDispatcher.class));
+		all.add(C(Connector.class, ThresholdConnector.class));
+
+		all.add(C(AlertManager.class).req(MailRecordDao.class));
+
+		all.add(C(ThresholdRuleManager.class).//
+		      req(AlarmTemplateDao.class, AlarmRuleDao.class));
 
 		all.add(C(ExceptionDataListener.class).//
-		      req(EventDispatcher.class));
+				req(EventDispatcher.class, ThresholdRuleManager.class));
+
+		all.add(C(ServiceDataListener.class).//
+				req(EventDispatcher.class, ThresholdRuleManager.class));
+
+		all.add(C(ThresholdAlertListener.class).//
+		      req(AlertManager.class, RuleManager.class));
 
-		all.add(C(ExceptionAlarmTask.class).//
-		      req(EventDispatcher.class));
+		all.add(C(AlarmTask.class).//
+		      req(EventDispatcher.class, Connector.class, ThresholdRuleManager.class));
 
 		return all;
 	}

cat-home/src/main/java/com/dianping/cat/helper/CatString.java

@@ -6,10 +6,16 @@ public class CatString {
 	public static final String ALL_Domain = "All";
 
 	public static final String ALL_Database = "All";
-	
+
 	public static final String ALL_NAME = "All";
 
 	public static final String ONLINE = "cat.dianpingoa.com";
-	
+
 	public static final String OFFLINE = "cat.qa.dianpingoa.com";
+
+	public static final String CAT = "Cat";
+
+	public static final String EXCEPTION = " 系统异常过多告警";
+
+	public static final String SERVICE = " 服务调用失败告警";
 }

cat-home/src/main/java/com/dianping/cat/report/page/cross/DomainManager.java

@@ -55,14 +55,16 @@ public class DomainManager implements Initializable {
 				Cat.logError(e);
 			}
 
-			Threads.forGroup("Cat").start(new Reload());
+			Threads.forGroup("Cat").start(new ReloadDomainTask());
 		}
 	}
 
-	class Reload implements Task {
+	class ReloadDomainTask implements Task {
 		@Override
 		public void run() {
-			while (true) {
+			boolean active = true;
+
+			while (active) {
 				try {
 					Set<String> addIps = new HashSet<String>();
 					synchronized (m_unknownIps) {
@@ -87,7 +89,7 @@ public class DomainManager implements Initializable {
 				try {
 					Thread.sleep(60 * 60 * 1000);
 				} catch (InterruptedException e) {
-					// igonre
+					active = false;
 				}
 			}
 		}

cat-home/src/main/java/com/dianping/cat/report/service/DailyReportService.java

@@ -33,5 +33,4 @@ public interface DailyReportService {
 
 	public HealthReport queryHealthReport(String domain, Date start, Date end);
 	
-	
 }

cat-home/src/main/java/com/dianping/cat/report/task/DailyTaskProducer.java

@@ -50,7 +50,6 @@ public class DailyTaskProducer implements com.site.helper.Threads.Task, Initiali
 			allReports = m_dailyReportDao.findDatabaseAllByPeriod(day, new Date(day.getTime() + DAY),
 			      DailyreportEntity.READSET_DOMAIN_NAME);
 		} catch (DalNotFoundException notFoundException) {
-			// Ignore
 		} catch (DalException e) {
 			Cat.logError(e);
 		}
@@ -71,7 +70,6 @@ public class DailyTaskProducer implements com.site.helper.Threads.Task, Initiali
 			allReports = m_dailyReportDao.findAllByPeriod(day, new Date(day.getTime() + DAY),
 			      DailyreportEntity.READSET_DOMAIN_NAME);
 		} catch (DalNotFoundException notFoundException) {
-			// Ignore
 		} catch (DalException e) {
 			Cat.logError(e);
 		}
@@ -211,7 +209,9 @@ public class DailyTaskProducer implements com.site.helper.Threads.Task, Initiali
 
 	@Override
 	public void run() {
-		while (true) {
+		boolean active = true;
+		
+		while (active) {
 			try {
 				Calendar cal = Calendar.getInstance();
 				int minute = cal.get(Calendar.MINUTE);
@@ -226,9 +226,13 @@ public class DailyTaskProducer implements com.site.helper.Threads.Task, Initiali
 						generateDatabaseTasks(yestoday);
 					}
 				}
-
-				Thread.sleep(10 * 60 * 1000);
 			} catch (Exception e) {
+				Cat.logError(e);
+			}
+			try {
+				Thread.sleep(10 * 60 * 1000);
+			} catch (InterruptedException e) {
+				active = false;
 			}
 		}
 	}

cat-home/src/main/java/com/dianping/cat/report/task/OtherJobReport.java

@@ -312,20 +312,20 @@ public class OtherJobReport implements Task {
 		}
 		buildServiceTotalInfo(domain, lastMonth, nextMonth);
 		buildServiceDetailInfo(domain, lastMonth, nextMonth, functionNames);
-		 buildOtherDomainCrossInfo(domain, lastMonth, nextMonth, otherDomains);
-		
-		 domain = "TuanGouWeb";
-		 urls.add("/index");
-		 urls.add("/detail");
-		 buildUrlTotalInfo(domain, lastMonth, nextMonth);
-		 buildUrlDetailsInfo(domain, lastMonth, nextMonth, urls);
-		
-		 domain = "BCTuangouWeb";
-		 buildUrlTotalInfo(domain, lastMonth, nextMonth);
-		 domain = "TuanGouApi";
-		 buildUrlTotalInfo(domain, lastMonth, nextMonth);
-		 domain = "TuanGouApiMobile";
-		 buildUrlTotalInfo(domain, lastMonth, nextMonth);
+		buildOtherDomainCrossInfo(domain, lastMonth, nextMonth, otherDomains);
+
+		domain = "TuanGouWeb";
+		urls.add("/index");
+		urls.add("/detail");
+		buildUrlTotalInfo(domain, lastMonth, nextMonth);
+		buildUrlDetailsInfo(domain, lastMonth, nextMonth, urls);
+
+		domain = "BCTuangouWeb";
+		buildUrlTotalInfo(domain, lastMonth, nextMonth);
+		domain = "TuanGouApi";
+		buildUrlTotalInfo(domain, lastMonth, nextMonth);
+		domain = "TuanGouApiMobile";
+		buildUrlTotalInfo(domain, lastMonth, nextMonth);
 
 	}
 

cat-home/src/main/java/com/dianping/cat/report/task/monthreport/MonthReportBuilderTask.java

@@ -205,7 +205,9 @@ public class MonthReportBuilderTask implements Task {
 	}
 
 	public void run() {
-		while (true) {
+		boolean active = true;
+		
+		while (active) {
 			try {
 				Date lastMonth = getMonthFirstDay(-1);
 				Date currentMonth = getMonthFirstDay(0);
@@ -242,7 +244,7 @@ public class MonthReportBuilderTask implements Task {
 				long sleepTime = getSleepTime();
 				Thread.sleep(sleepTime);
 			} catch (InterruptedException e) {
-				// Ignore
+				active = false;
 			}
 		}
 	}

cat-home/src/main/java/com/dianping/cat/system/SystemPage.java

@@ -9,16 +9,26 @@ public enum SystemPage implements Page {
 
    LOGIN("login", "login", "Login", "Login", false);
 
-   private String m_name;
-
-   private String m_path;
+   public static SystemPage getByName(String name, SystemPage defaultPage) {
+      for (SystemPage action : SystemPage.values()) {
+         if (action.getName().equals(name)) {
+            return action;
+         }
+      }
 
-   private String m_title;
+      return defaultPage;
+   }
 
    private String m_description;
 
+   private String m_name;
+
+   private String m_path;
+
    private boolean m_standalone;
 
+   private String m_title;
+
    private SystemPage(String name, String path, String title, String description, boolean standalone) {
       m_name = name;
       m_path = path;
@@ -27,16 +37,6 @@ public enum SystemPage implements Page {
       m_standalone = standalone;
    }
 
-   public static SystemPage getByName(String name, SystemPage defaultPage) {
-      for (SystemPage action : SystemPage.values()) {
-         if (action.getName().equals(name)) {
-            return action;
-         }
-      }
-
-      return defaultPage;
-   }
-
    public String getDescription() {
       return m_description;
    }
@@ -65,11 +65,11 @@ public enum SystemPage implements Page {
       return m_title;
    }
 
-   public boolean isStandalone() {
-      return m_standalone;
-   }
-
    public SystemPage[] getValues() {
       return SystemPage.values();
    }
+
+   public boolean isStandalone() {
+      return m_standalone;
+   }
 }

cat-home/src/main/java/com/dianping/cat/system/alarm/DefaultAlarmCreator.java → cat-home/src/main/java/com/dianping/cat/system/alarm/AlarmRuleCreator.java

@@ -26,7 +26,7 @@ import com.site.dal.jdbc.DalNotFoundException;
 import com.site.helper.Threads.Task;
 import com.site.lookup.annotation.Inject;
 
-public class DefaultAlarmCreator implements Task {
+public class AlarmRuleCreator implements Task {
 
 	@Inject
 	private AlarmRuleDao m_alarmRuleDao;
@@ -41,13 +41,13 @@ public class DefaultAlarmCreator implements Task {
 	private ModelService<EventReport> m_service;
 
 	/**
-	 * Get all domains for realtime
+	 * Get all domains from realtime
 	 * 
 	 * @return
 	 * @throws DalException
 	 */
 	private Set<String> getAllDomains() throws DalException {
-		String domain = "Cat";
+		String domain = CatString.CAT;
 		ModelRequest request = new ModelRequest(domain, ModelPeriod.CURRENT)//
 		      .setProperty("ip", CatString.ALL_IP);
 
@@ -76,9 +76,9 @@ public class DefaultAlarmCreator implements Task {
 
 	private void insertScheduled(String domain) throws DalException {
 		ScheduledReport entity = m_scheduledReportDao.createLocal();
+
 		entity.setDomain(domain);
 		entity.setNames("transaction;event;problem;health");
-
 		m_scheduledReportDao.insert(entity);
 	}
 
@@ -98,10 +98,12 @@ public class DefaultAlarmCreator implements Task {
 	@Override
 	public void run() {
 		try {
-			Thread.sleep(5 * 1000);
+			Thread.sleep(10 * 1000);
 		} catch (InterruptedException e1) {
 		}
-		while (true) {
+		boolean active = true;
+
+		while (active) {
 			try {
 				int exceptionTemplateId = queryTemplateByName("exception").getId();
 				int serviceTemplateId = queryTemplateByName("service").getId();
@@ -167,7 +169,7 @@ public class DefaultAlarmCreator implements Task {
 			try {
 				Thread.sleep(10 * 60 * 1000);
 			} catch (Exception e) {
-				// ignore
+				active = false;
 			}
 		}
 

cat-home/src/main/java/com/dianping/cat/system/alarm/AlarmTask.java

+package com.dianping.cat.system.alarm;
+
+import java.util.List;
+
+import com.dianping.cat.Cat;
+import com.dianping.cat.message.Transaction;
+import com.dianping.cat.system.alarm.connector.Connector;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
+import com.dianping.cat.system.alarm.threshold.ThresholdRule;
+import com.dianping.cat.system.alarm.threshold.ThresholdRuleManager;
+import com.dianping.cat.system.alarm.threshold.event.ExceptionDataEvent;
+import com.dianping.cat.system.alarm.threshold.event.ServiceDataEvent;
+import com.dianping.cat.system.event.EventDispatcher;
+import com.site.helper.Threads.Task;
+import com.site.lookup.annotation.Inject;
+
+public class AlarmTask implements Task {
+
+	@Inject
+	private Connector m_connector;
+
+	@Inject
+	private EventDispatcher m_dispatcher;
+
+	@Inject
+	private ThresholdRuleManager m_manager;
+
+	@Override
+	public String getName() {
+		return "Exception-Alarm";
+	}
+
+	@Override
+	public void run() {
+		boolean active = true;
+
+		while (active) {
+			Transaction t = Cat.newTransaction("System", "Alarm");
+			long time = System.currentTimeMillis();
+
+			try {
+				getExceptionRule();
+				getServiceRule();
+				t.setStatus(Transaction.SUCCESS);
+			} catch (Exception e) {
+				t.setStatus(e);
+			}
+			t.complete();
+
+			long duration = System.currentTimeMillis() - time;
+			try {
+				Thread.sleep(20 * 1000 - duration);
+			} catch (InterruptedException e) {
+				active = false;
+			}
+		}
+	}
+
+	private void getServiceRule() {
+		List<ThresholdRule> rules = m_manager.getAllServiceRules();
+		
+		for (ThresholdRule rule : rules) {
+			Transaction t = Cat.newTransaction("ServiceAlarm", rule.getDomain());
+			
+			try {
+				ThresholdDataEntity entity = m_connector.fetchAlarmData(rule.getConnectUrl());
+				
+				entity.setDomain(rule.getDomain());
+				
+				ServiceDataEvent event = new ServiceDataEvent(entity);
+
+				m_dispatcher.dispatch(event);
+				t.addData(event.toString());
+				t.setStatus(Transaction.SUCCESS);
+			} catch (Exception e) {
+				t.setStatus(e);
+				Cat.logError(e);
+			} finally {
+				t.complete();
+			}
+		}
+	}
+
+	private void getExceptionRule() {
+		List<ThresholdRule> rules = m_manager.getAllExceptionRules();
+		
+		for (ThresholdRule rule : rules) {
+			Transaction t = Cat.newTransaction("ExceptionAlarm", rule.getDomain());
+			
+			try {
+				ThresholdDataEntity entity = m_connector.fetchAlarmData(rule.getConnectUrl());
+				
+				entity.setDomain(rule.getDomain());
+				ExceptionDataEvent event = new ExceptionDataEvent(entity);
+
+				m_dispatcher.dispatch(event);
+				t.addData(event.toString());
+				t.setStatus(Transaction.SUCCESS);
+			} catch (Exception e) {
+				t.setStatus(e);
+				Cat.logError(e);
+			} finally {
+				t.complete();
+			}
+		}
+	}
+
+	@Override
+	public void shutdown() {
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/ExceptionAlarmTask.java

-package com.dianping.cat.system.alarm;
-
-import com.dianping.cat.system.alarm.connector.Connector;
-import com.dianping.cat.system.alarm.exception.ExceptionDataEntity;
-import com.dianping.cat.system.alarm.exception.ExceptionRuleManager;
-import com.dianping.cat.system.alarm.exception.event.ExceptionDataEvent;
-import com.dianping.cat.system.event.EventDispatcher;
-import com.site.helper.Threads.Task;
-import com.site.lookup.annotation.Inject;
-
-public class ExceptionAlarmTask implements Task {
-
-	@Inject
-	private ExceptionRuleManager m_manager;
-
-	@Inject
-	private Connector m_connector;
-
-	@Inject
-	private EventDispatcher m_dispatcher;
-
-	@Override
-	public void run() {
-		while (true) {
-			long time = System.currentTimeMillis();
-
-			try {
-				ExceptionDataEvent event = new ExceptionDataEvent();
-				event.setData(new ExceptionDataEntity());
-				m_dispatcher.dispatch(event);
-			} catch (Exception e) {
-
-			}
-			long duration = System.currentTimeMillis() - time;
-			try {
-				Thread.sleep(3 * 1000 - duration);
-			} catch (Exception e) {
-				// igrone
-			}
-		}
-	}
-
-	@Override
-	public String getName() {
-		return "ExceptionAlarm";
-	}
-
-	@Override
-	public void shutdown() {
-	}
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/alert/AlertInfo.java

+package com.dianping.cat.system.alarm.alert;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+public class AlertInfo {
+
+	public static final String EMAIL = "email";
+
+	public static final int EMAIL_TYPE = 0;
+
+	public static final String EXCEPTION = "exception";
+
+	public static final String SERVICE = "service";
+
+	public static final String SMS = "sms";
+
+	public static final int SMS_TYPE = 1;
+
+	private String m_content;
+
+	private Date m_date;
+
+	private List<String> m_mails;
+
+	private List<String> m_phones;
+
+	private int m_ruleId;
+
+	private String m_title;
+
+	private int m_type;
+
+	public String getContent() {
+		return m_content;
+	}
+
+	public Date getDate() {
+		return m_date;
+	}
+
+	public List<String> getMails() {
+		if (m_mails == null) {
+			return new ArrayList<String>();
+		}
+		return m_mails;
+	}
+
+	public List<String> getPhones() {
+		if (m_phones == null) {
+			return new ArrayList<String>();
+		}
+		return m_phones;
+	}
+
+	public int getRuleId() {
+		return m_ruleId;
+	}
+
+	public String getTitle() {
+		return m_title;
+	}
+
+	public int getType() {
+		return m_type;
+	}
+
+	public AlertInfo setContent(String content) {
+		m_content = content;
+		return this;
+	}
+
+	public AlertInfo setDate(Date date) {
+		m_date = date;
+		return this;
+	}
+
+	public AlertInfo setMails(List<String> mails) {
+		m_mails = mails;
+		return this;
+	}
+
+	public void setPhones(List<String> phones) {
+		m_phones = phones;
+	}
+
+	public void setRuleId(int ruleId) {
+		m_ruleId = ruleId;
+	}
+
+	public AlertInfo setTitle(String title) {
+		m_title = title;
+		return this;
+	}
+
+	public void setType(int type) {
+		m_type = type;
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/alert/AlertManager.java

+package com.dianping.cat.system.alarm.alert;
+
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
+import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
+
+import com.dianping.cat.Cat;
+import com.dianping.cat.home.dal.alarm.MailRecord;
+import com.dianping.cat.home.dal.alarm.MailRecordDao;
+import com.dianping.cat.message.Transaction;
+import com.site.helper.Threads;
+import com.site.helper.Threads.Task;
+import com.site.lookup.annotation.Inject;
+
+public class AlertManager implements Initializable {
+
+	private final BlockingQueue<AlertInfo> m_alarmInfos = new LinkedBlockingQueue<AlertInfo>(1000);
+
+	@Inject
+	private MailRecordDao m_mailRecordDao;
+
+	public void addAlarmInfo(int type, String title, String content, List<String> address, int ruleId, Date date) {
+		AlertInfo info = new AlertInfo();
+
+		info.setContent(content);
+		info.setTitle(title);
+		info.setType(type);
+		info.setRuleId(ruleId);
+		info.setDate(date);
+		if (type == AlertInfo.EMAIL_TYPE) {
+			info.setMails(address);
+		} else {
+			info.setPhones(address);
+		}
+		m_alarmInfos.offer(info);
+	}
+
+	@Override
+	public void initialize() throws InitializationException {
+		SendAlarmTask sendAlarmTask = new SendAlarmTask();
+
+		Threads.forGroup("Cat-Alarm").start(sendAlarmTask);
+	}
+
+	private void insert(AlertInfo info, int status) {
+		MailRecord record = m_mailRecordDao.createLocal();
+
+		record.setContent(info.getContent());
+		record.setTitle(info.getTitle());
+		record.setRuleId(info.getRuleId());
+		record.setReceivers(info.getMails().toString());
+		record.setStatus(status);
+		record.setType(1);// for alarm type
+		try {
+			m_mailRecordDao.insert(record);
+		} catch (Exception e) {
+			Cat.logError(e);
+		}
+	}
+
+	public class SendAlarmTask implements Task {
+
+		@Override
+		public String getName() {
+			return "Send-Alarm";
+		}
+
+		@Override
+		public void run() {
+			boolean active = true;
+			
+			while (active) {
+				try {
+					AlertInfo entity = m_alarmInfos.poll(5, TimeUnit.MILLISECONDS);
+
+					if (entity != null) {
+						Transaction t = Cat.newTransaction("System", "Email");
+						// Send Email
+						// boolean result
+						insert(entity, 1);
+						t.addData(entity.getContent() + entity.getTitle());
+						t.setStatus(Transaction.SUCCESS);
+						t.complete();
+					} else {
+						try {
+							Thread.sleep(2 * 1000);
+						} catch (InterruptedException e) {
+							active = false;
+						}
+					}
+				} catch (Exception e) {
+					Cat.logError(e);
+				}
+
+			}
+		}
+
+		@Override
+		public void shutdown() {
+		}
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/connector/Connector.java

 package com.dianping.cat.system.alarm.connector;
 
-import com.dianping.cat.system.alarm.exception.ExceptionDataEntity;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
 
 public interface Connector {
 
-	public ExceptionDataEntity fetchAlarmData(String url);
+	public ThresholdDataEntity fetchAlarmData(String url);
 }

cat-home/src/main/java/com/dianping/cat/system/alarm/connector/ConnectorManager.java

-package com.dianping.cat.system.alarm.connector;
-
-public class ConnectorManager {
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/connector/impl/CatConnector.java → cat-home/src/main/java/com/dianping/cat/system/alarm/connector/impl/ThresholdConnector.java

@@ -7,46 +7,53 @@ import java.util.Date;
 import java.util.Map;
 
 import com.dianping.cat.Cat;
+import com.dianping.cat.message.Event;
 import com.dianping.cat.system.alarm.connector.Connector;
-import com.dianping.cat.system.alarm.exception.ExceptionDataEntity;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import com.site.helper.Files;
 
-public class CatConnector implements Connector {
+public class ThresholdConnector implements Connector {
+	public static int index = 1;
 
 	@Override
-	public ExceptionDataEntity fetchAlarmData(String url) {
+	public ThresholdDataEntity fetchAlarmData(String url) {
+		Cat.getProducer().logEvent("System", "AlarmUrl", Event.SUCCESS, url);
 		try {
 			return getContent(url);
 		} catch (Exception e) {
 			try {
 				return getContent(url);
-			} catch (Exception e1) {
-				Cat.logError(e1);
+			} catch (Exception ex) {
+				Cat.logError(ex);
 			}
 		}
 		return null;
 	}
 
-	private ExceptionDataEntity getContent(String url) throws MalformedURLException, IOException {
+	private ThresholdDataEntity getContent(String url) throws MalformedURLException, IOException {
 		URL data = new URL(url);
 		String content = Files.forIO().readFrom(data.openStream(), "utf-8");
 
 		return parseContent(content);
 	}
 
-	private ExceptionDataEntity parseContent(String content) {
+	private ThresholdDataEntity parseContent(String content) {
 		Gson gson = new Gson();
 		Map<String, String> obj = gson.fromJson(content.trim(), new TypeToken<Map<String, String>>() {
 		}.getType());
 
-		ExceptionDataEntity data = new ExceptionDataEntity();
+		ThresholdDataEntity data = new ThresholdDataEntity();
 		String count = obj.get("Count");
 
 		if (count != null) {
 			data.setCount(Long.parseLong(count));
+
 		}
+		// TODO
+		data.setCount(index * 100);
+		index++;
 
 		String timestamp = obj.get("timestamp");
 		if (timestamp != null) {

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/ExceptionRule.java

-package com.dianping.cat.system.alarm.exception;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class ExceptionRule {
-
-	private String m_connectUrl;
-
-	private Map<String, Duration> m_durations = new HashMap<String,Duration>();
-	
-	public String getConnectUrl() {
-		return m_connectUrl;
-	}
-
-	public void setConnectUrl(String connectUrl) {
-		m_connectUrl = connectUrl;
-	}
-
-	public Map<String, Duration> getDurations() {
-		return m_durations;
-	}
-
-	public void setDurations(Map<String, Duration> durations) {
-		m_durations = durations;
-	}
-
-	public static class Duration {
-
-		private int m_interval;
-
-		private int m_min;
-
-		private int m_max;
-
-		private String m_strategy;
-
-		public int getInterval() {
-			return m_interval;
-		}
-
-		public void setInterval(int interval) {
-			m_interval = interval;
-		}
-
-		public int getMin() {
-			return m_min;
-		}
-
-		public void setMin(int min) {
-			m_min = min;
-		}
-
-		public int getMax() {
-			return m_max;
-		}
-
-		public void setMax(int max) {
-			m_max = max;
-		}
-
-		public String getStrategy() {
-			return m_strategy;
-		}
-
-		public void setStrategy(String strategy) {
-			m_strategy = strategy;
-		}
-	}
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/ExceptionRuleManager.java

-package com.dianping.cat.system.alarm.exception;
-
-import java.util.List;
-
-import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
-import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
-
-import com.dianping.cat.Cat;
-import com.dianping.cat.home.dal.alarm.AlarmRule;
-import com.dianping.cat.home.dal.alarm.AlarmRuleDao;
-import com.dianping.cat.home.dal.alarm.AlarmRuleEntity;
-import com.dianping.cat.home.dal.alarm.AlarmTemplate;
-import com.dianping.cat.home.dal.alarm.AlarmTemplateDao;
-import com.dianping.cat.home.dal.alarm.AlarmTemplateEntity;
-import com.dianping.cat.home.template.entity.ThresholdTemplate;
-import com.dianping.cat.home.template.transform.DefaultSaxParser;
-import com.dianping.cat.system.alarm.template.TemplateMerger;
-import com.dianping.cat.system.alarm.template.ThresholdRule;
-import com.site.lookup.annotation.Inject;
-
-public class ExceptionRuleManager implements Initializable {
-
-	public List<ThresholdRule> m_rules;
-
-	@Inject
-	private AlarmTemplateDao m_alarmTemplateDao;
-
-	@Inject
-	private AlarmRuleDao m_alarmRuleDao;
-
-	public List<ThresholdRule> getAllExceptionRules() {
-		return m_rules;
-	}
-
-	@Override
-	public void initialize() throws InitializationException {
-		try {
-			AlarmTemplate alarmTemplate = m_alarmTemplateDao.findAlarmTemplateByName("exception",
-			      AlarmTemplateEntity.READSET_FULL);
-			int templateId = alarmTemplate.getId();
-			String content = alarmTemplate.getContent();
-			ThresholdTemplate baseTemplate = DefaultSaxParser.parse(content);
-
-			List<AlarmRule> exceptionRules = m_alarmRuleDao.findAllAlarmRuleByTemplateId(templateId,
-			      AlarmRuleEntity.READSET_FULL);
-
-			for (AlarmRule rule : exceptionRules) {
-				try {
-					String newContent = rule.getContent();
-					ThresholdTemplate newTemplate = DefaultSaxParser.parse(newContent);
-					TemplateMerger merger = new TemplateMerger(new ThresholdTemplate());
-
-					baseTemplate.accept(merger);
-					newTemplate.accept(merger);
-
-					@SuppressWarnings("unused")
-               ThresholdTemplate template = merger.getThresholdTemplate();
-
-				} catch (Exception e) {
-					Cat.logError(e);
-				}
-			}
-
-		} catch (Exception e) {
-			throw new RuntimeException(e);
-		}
-	}
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/listener/ExceptionAlertListener.java

-package com.dianping.cat.system.alarm.exception.listener;
-
-import com.dianping.cat.system.alarm.exception.event.ExceptionAlertEvent;
-import com.dianping.cat.system.event.Event;
-import com.dianping.cat.system.event.EventDispatcher;
-import com.dianping.cat.system.event.EventListener;
-import com.dianping.cat.system.event.EventType;
-import com.site.lookup.annotation.Inject;
-
-public class ExceptionAlertListener implements EventListener {
-
-	@Inject
-	private EventDispatcher m_dispatcher;
-	
-	@Override
-	public boolean isEligible(Event event) {
-		if (event.getEventType() == EventType.ExceptionAlertEvent) {
-			return true;
-		}
-		return false;
-	}
-
-	@Override
-	public void onEvent(Event event) {
-		//确定状态发出告警
-		ExceptionAlertEvent alertEvent = (ExceptionAlertEvent)event;
-		alertEvent.toString();
-		System.out.println("Send Alarm");
-		// TODO Auto-generated method stub
-	}
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/listener/ExceptionDataListener.java

-package com.dianping.cat.system.alarm.exception.listener;
-
-import com.dianping.cat.system.alarm.exception.event.ExceptionAlertEvent;
-import com.dianping.cat.system.event.Event;
-import com.dianping.cat.system.event.EventDispatcher;
-import com.dianping.cat.system.event.EventListener;
-import com.dianping.cat.system.event.EventType;
-import com.site.lookup.annotation.Inject;
-
-public class ExceptionDataListener implements EventListener {
-
-	@Inject
-	private EventDispatcher m_dispatcher;
-
-	@Override
-	public boolean isEligible(Event event) {
-		if (event.getEventType() == EventType.ExceptionDataEvent) {
-			return true;
-		}
-		return false;
-	}
-
-	@Override
-	public void onEvent(Event event) {
-		System.out.println("Get Data");
-
-		ExceptionAlertEvent alertEvent = new ExceptionAlertEvent();
-		m_dispatcher.dispatch(alertEvent);
-		// 匹配数据，发出告警
-		// TODO Auto-generated method stub
-
-	}
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/strategy/StrategyManager.java

-package com.dianping.cat.system.alarm.strategy;
-
-public class StrategyManager {
-
-	
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/template/TemplateMerger.java

-package com.dianping.cat.system.alarm.template;
-
-import com.dianping.cat.home.template.entity.Connection;
-import com.dianping.cat.home.template.entity.Duration;
-import com.dianping.cat.home.template.entity.Param;
-import com.dianping.cat.home.template.entity.ThresholdTemplate;
-import com.dianping.cat.home.template.transform.DefaultMerger;
-
-public class TemplateMerger extends DefaultMerger{
-
-	public TemplateMerger(ThresholdTemplate thresholdTemplate) {
-	   super(thresholdTemplate);
-   }
-
-	@Override
-   protected void mergeConnection(Connection old, Connection connection) {
-	   super.mergeConnection(old, connection);
-   }
-
-	@Override
-   protected void mergeDuration(Duration old, Duration duration) {
-	   old.setMin(duration.getMin());
-	   old.setMax(duration.getMax());
-	   old.setInterval(duration.getInterval());
-	   old.setAlarm(duration.getAlarm());
-	   old.setId(duration.getId());
-   }
-
-	@Override
-   protected void mergeParam(Param old, Param param) {
-		old.setValue(param.getValue());
-		old.setType(param.getType());
-   }
-
-
-	@Override
-   protected void mergeThresholdTemplate(ThresholdTemplate old, ThresholdTemplate thresholdTemplate) {
-	   super.mergeThresholdTemplate(old, thresholdTemplate);
-   }
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/template/ThresholdEntity.java

-package com.dianping.cat.system.alarm.template;
-
-public class ThresholdEntity {
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/template/ThresholdRule.java

-package com.dianping.cat.system.alarm.template;
-
-import com.dianping.cat.system.alarm.exception.ExceptionDataEntity;
-
-public interface ThresholdRule {
-
-	public String getConnectUrl();
-
-	public void addData(ExceptionDataEntity data);
-
-	public String match();
-
-}

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/ExceptionDataEntity.java → cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/ThresholdDataEntity.java

-package com.dianping.cat.system.alarm.exception;
+package com.dianping.cat.system.alarm.threshold;
 
 import java.util.Date;
 
-public class ExceptionDataEntity {
-
-	private Date m_date;
+public class ThresholdDataEntity {
 
 	private long m_count;
 
+	private Date m_date;
+	
+	private String m_domain;
+	
+	public long getCount() {
+		return m_count;
+	}
+
 	public Date getDate() {
 		return m_date;
 	}
 
+	public String getDomain() {
+		return m_domain;
+	}
+
+	public void setCount(long count) {
+		m_count = count;
+	}
+
 	public void setDate(Date date) {
 		m_date = date;
 	}
 
-	public long getCount() {
-		return m_count;
+	public void setDomain(String domain) {
+		m_domain = domain;
 	}
-
-	public void setCount(long count) {
-		m_count = count;
+	
+	public String toString(){
+		StringBuilder sb = new StringBuilder("[");
+		sb.append("Date:").append(m_date).append(";");
+		sb.append("Count:").append(m_count).append(";");
+		sb.append("Domain:").append(m_domain).append("]");
+		
+		return sb.toString();
 	}
 
 }

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/ThresholdRule.java

+package com.dianping.cat.system.alarm.threshold;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.dianping.cat.helper.TimeUtil;
+import com.dianping.cat.home.template.entity.Duration;
+import com.dianping.cat.home.template.entity.Param;
+import com.dianping.cat.home.template.entity.ThresholdTemplate;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdAlarmMeta;
+
+public class ThresholdRule {
+
+	private String m_connectionUrl;
+
+	private List<ThresholdDataEntity> m_datas = new ArrayList<ThresholdDataEntity>();
+
+	private String m_domain;
+
+	private Map<String, Long> m_lastAlarmTime = new HashMap<String, Long>();
+
+	private ThresholdDataEntity m_lastData;
+
+	private int m_ruleId;
+
+	private ThresholdTemplate m_template;
+
+	public ThresholdRule(int ruleId, String domain, ThresholdTemplate template) {
+		m_ruleId = ruleId;
+		m_domain = domain;
+		refreshTemplate(template);
+	}
+
+	public ThresholdAlarmMeta addData(ThresholdDataEntity entity,String type) {
+		if (validateData(entity)) {
+			List<Duration> durations = getDurations();
+			int length = durations.size();
+
+			for (int i = length - 1; i > 0; i--) {
+				Duration duration = durations.get(i);
+				String strategy = duration.getAlarm();
+
+				if (strategy != null && strategy.length() > 0) {
+					int interval = duration.getInterval();
+					long count = getCount(interval, entity.getDate());
+
+					if (count >= duration.getMin() && count <= duration.getMax()) {
+						ThresholdAlarmMeta meta = new ThresholdAlarmMeta();
+
+						meta.setDuration(duration).setRealCount(count).setType(type);
+						meta.setRuleId(m_ruleId).setDomain(m_domain).setDate(entity.getDate());
+						meta.setBaseUrl(m_template.getConnection().getBaseUrl());
+
+						if (needAlarm(entity, duration)) {
+							m_lastAlarmTime.put(m_ruleId + ":" + duration.getId(), entity.getDate().getTime());
+							return meta;
+						}
+						return null;
+					}
+				}
+			}
+
+			cleanData(getMaxInterval(), entity.getDate().getTime());
+		}
+		return null;
+	}
+
+	public void cleanData(int maxInterval, long time) {
+		long start = time - (maxInterval + 1) * TimeUtil.ONE_MINUTE;
+
+		List<ThresholdDataEntity> removes = new ArrayList<ThresholdDataEntity>();
+		for (ThresholdDataEntity entity : m_datas) {
+			if (entity.getDate().getTime() < start) {
+				removes.add(entity);
+			}
+		}
+
+		for (ThresholdDataEntity entity : removes) {
+			m_datas.remove(entity);
+		}
+	}
+
+	public String getConnectUrl() {
+		return m_connectionUrl;
+	}
+
+	public long getCount(int interval, Date date) {
+		long start = date.getTime() - interval * 60 * 1000;
+		long totalCount = 0;
+
+		ThresholdDataEntity last = null;
+		ThresholdDataEntity first = null;
+
+		int length = m_datas.size();
+		for (int i = 0; i < length; i++) {
+			ThresholdDataEntity entity = m_datas.get(i);
+
+			if (entity.getDate().getTime() > start) {
+				if (last == null) {
+					last = entity;
+					first = entity;
+				} else {
+					if (entity.getCount() >= last.getCount() && i == length - 1) {
+						totalCount += entity.getCount() - first.getCount();
+					} else if (entity.getCount() < last.getCount()) {
+						totalCount += last.getCount() - first.getCount();
+						totalCount += entity.getCount();
+						first = entity;
+						last = entity;
+					} else {
+						last = entity;
+					}
+				}
+			}
+		}
+
+		return totalCount;
+	}
+
+	public List<ThresholdDataEntity> getDatas() {
+		return m_datas;
+	}
+
+	public String getDomain() {
+		return m_domain;
+	}
+
+	public List<Duration> getDurations() {
+		return new ArrayList<Duration>(m_template.getDurations().values());
+	}
+
+	public Map<String, Long> getLastAlarmTime() {
+		return m_lastAlarmTime;
+	}
+
+	public int getMaxInterval() {
+		List<Duration> durations = getDurations();
+		int max = 0;
+
+		for (Duration duration : durations) {
+			Integer interval = duration.getInterval();
+
+			if (interval > max) {
+				max = interval;
+			}
+		}
+		return max;
+	}
+	
+	public int getRuleId() {
+		return m_ruleId;
+	}
+
+	private boolean needAlarm(ThresholdDataEntity entity, Duration duration) {
+		Long currentTime = entity.getDate().getTime();
+		Long lastAlarmTime = m_lastAlarmTime.get(m_ruleId + ":" + duration.getId());
+
+		if (lastAlarmTime == null || (currentTime - lastAlarmTime) > duration.getAlarmInterval() * TimeUtil.ONE_MINUTE) {
+			return true;
+		}
+		return false;
+	}
+
+	public void refreshTemplate(ThresholdTemplate template) {
+		m_template = template;
+
+		StringBuilder sb = new StringBuilder();
+		sb.append(m_template.getConnection().getBaseUrl());
+		sb.append("?");
+
+		Collection<Param> pars = m_template.getConnection().getParams().values();
+
+		for (Param par : pars) {
+			sb.append(par.getType()).append("=").append(par.getValue()).append("&");
+		}
+		sb.append("domain=").append(m_domain);
+		m_connectionUrl = sb.toString();
+	}
+
+	public void setDomain(String domain) {
+		m_domain = domain;
+	}
+
+	public void setTemplate(ThresholdTemplate template) {
+		m_template = template;
+	}
+
+	private boolean validateData(ThresholdDataEntity entity) {
+		if (entity.getDate().getTime() > System.currentTimeMillis()) {
+			return false;
+		}
+		if (m_lastData == null) {
+			m_datas.add(entity);
+			m_lastData = entity;
+			return true;
+		} else {
+			long newCount = entity.getCount();
+			long lastCount = m_lastData.getCount();
+
+			if (newCount > lastCount) {
+				m_datas.add(entity);
+				m_lastData = entity;
+				return true;
+			} else {
+				Calendar cal = Calendar.getInstance();
+				cal.setTime(entity.getDate());
+
+				int minute = cal.get(Calendar.MINUTE);
+				if (minute == 0) {
+					m_datas.add(entity);
+					m_lastData = entity;
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/ThresholdRuleManager.java

+package com.dianping.cat.system.alarm.threshold;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
+import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
+
+import com.dianping.cat.Cat;
+import com.dianping.cat.home.dal.alarm.AlarmRule;
+import com.dianping.cat.home.dal.alarm.AlarmRuleDao;
+import com.dianping.cat.home.dal.alarm.AlarmRuleEntity;
+import com.dianping.cat.home.dal.alarm.AlarmTemplate;
+import com.dianping.cat.home.dal.alarm.AlarmTemplateDao;
+import com.dianping.cat.home.dal.alarm.AlarmTemplateEntity;
+import com.dianping.cat.home.template.entity.ThresholdTemplate;
+import com.dianping.cat.home.template.transform.DefaultSaxParser;
+import com.dianping.cat.message.Event;
+import com.dianping.cat.message.Transaction;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdTemplateMerger;
+import com.site.helper.Threads;
+import com.site.helper.Threads.Task;
+import com.site.lookup.annotation.Inject;
+
+public class ThresholdRuleManager implements Initializable {
+
+	@Inject
+	private AlarmRuleDao m_alarmRuleDao;
+
+	@Inject
+	private AlarmTemplateDao m_alarmTemplateDao;
+
+	public Map<Integer, Date> m_exceptionModifyTimes = new HashMap<Integer, Date>();
+
+	public Map<Integer, Date> m_serviceModifyTimes = new HashMap<Integer, Date>();
+
+	public final Map<String, ArrayList<ThresholdRule>> m_exceptionRules = new HashMap<String, ArrayList<ThresholdRule>>();
+
+	public final Map<String, ArrayList<ThresholdRule>> m_serviceRules = new HashMap<String, ArrayList<ThresholdRule>>();
+
+	private void addExceptionRule(AlarmRule rule, ThresholdTemplate template) {
+		String domain = rule.getDomain();
+		ThresholdRule thresholdRule = new ThresholdRule(rule.getId(), domain, template);
+
+		ArrayList<ThresholdRule> rules = m_exceptionRules.get(domain);
+
+		if (rules == null) {
+			rules = new ArrayList<ThresholdRule>();
+
+			rules.add(thresholdRule);
+			m_exceptionRules.put(domain, rules);
+		} else {
+			rules.add(thresholdRule);
+		}
+	}
+
+	private void addServiceRule(AlarmRule rule, ThresholdTemplate template) {
+		String domain = rule.getDomain();
+		ThresholdRule thresholdRule = new ThresholdRule(rule.getId(), domain, template);
+
+		ArrayList<ThresholdRule> rules = m_serviceRules.get(domain);
+
+		if (rules == null) {
+			rules = new ArrayList<ThresholdRule>();
+
+			rules.add(thresholdRule);
+			m_serviceRules.put(domain, rules);
+		} else {
+			rules.add(thresholdRule);
+		}
+	}
+
+	public List<ThresholdRule> getAllExceptionRules() {
+		List<ThresholdRule> result = new ArrayList<ThresholdRule>();
+
+		for (ArrayList<ThresholdRule> rule : m_exceptionRules.values()) {
+			result.addAll(rule);
+		}
+		return result;
+	}
+
+	public List<ThresholdRule> getAllServiceRules() {
+		List<ThresholdRule> result = new ArrayList<ThresholdRule>();
+
+		for (ArrayList<ThresholdRule> rule : m_serviceRules.values()) {
+			result.addAll(rule);
+		}
+		return result;
+	}
+
+	public List<ThresholdRule> getExceptionRuleByDomain(String domain) {
+		ArrayList<ThresholdRule> arrayList = m_exceptionRules.get(domain);
+
+		if (arrayList != null) {
+			return arrayList;
+		}
+		return new ArrayList<ThresholdRule>();
+	}
+
+	public List<ThresholdRule> getServiceRuleByDomain(String domain) {
+		ArrayList<ThresholdRule> arrayList = m_serviceRules.get(domain);
+
+		if (arrayList != null) {
+			return arrayList;
+		}
+		return new ArrayList<ThresholdRule>();
+	}
+
+	@Override
+	public void initialize() throws InitializationException {
+		initalizeExceptionRule();
+		initalizeServiceRule();
+
+		ReloadThresholdRuleTask task = new ReloadThresholdRuleTask();
+
+		Threads.forGroup("Cat-Alarm").start(task);
+	}
+
+	private void initalizeExceptionRule() {
+		try {
+			AlarmTemplate alarmTemplate = m_alarmTemplateDao.findAlarmTemplateByName("exception",
+			      AlarmTemplateEntity.READSET_FULL);
+			int templateId = alarmTemplate.getId();
+			String content = alarmTemplate.getContent();
+			ThresholdTemplate baseTemplate = DefaultSaxParser.parse(content);
+
+			List<AlarmRule> exceptionRules = m_alarmRuleDao.findAllAlarmRuleByTemplateId(templateId,
+			      AlarmRuleEntity.READSET_FULL);
+
+			for (AlarmRule rule : exceptionRules) {
+				m_exceptionModifyTimes.put(rule.getId(), rule.getModifyDate());
+
+				try {
+					String newContent = rule.getContent().trim();
+					ThresholdTemplate template = mergerTemplate(baseTemplate, newContent);
+
+					addExceptionRule(rule, template);
+					m_exceptionModifyTimes.put(rule.getId(), rule.getModifyDate());
+				} catch (Exception e) {
+					Cat.logError(e);
+				}
+			}
+
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private void initalizeServiceRule() {
+		try {
+			AlarmTemplate alarmTemplate = m_alarmTemplateDao.findAlarmTemplateByName("service",
+			      AlarmTemplateEntity.READSET_FULL);
+			int templateId = alarmTemplate.getId();
+			String content = alarmTemplate.getContent();
+			ThresholdTemplate baseTemplate = DefaultSaxParser.parse(content);
+
+			List<AlarmRule> serviceRules = m_alarmRuleDao.findAllAlarmRuleByTemplateId(templateId,
+			      AlarmRuleEntity.READSET_FULL);
+
+			for (AlarmRule rule : serviceRules) {
+				m_serviceModifyTimes.put(rule.getId(), rule.getModifyDate());
+
+				try {
+					String newContent = rule.getContent().trim();
+					ThresholdTemplate template = mergerTemplate(baseTemplate, newContent);
+
+					addServiceRule(rule, template);
+					m_serviceModifyTimes.put(rule.getId(), rule.getModifyDate());
+				} catch (Exception e) {
+					Cat.logError(e);
+				}
+			}
+
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private ThresholdTemplate mergerTemplate(ThresholdTemplate baseTemplate, String newContent) {
+		if (newContent == null || newContent.length() > 0) {
+			try {
+				ThresholdTemplate newTemplate = DefaultSaxParser.parse(newContent);
+				ThresholdTemplateMerger merger = new ThresholdTemplateMerger(new ThresholdTemplate());
+
+				baseTemplate.accept(merger);
+				newTemplate.accept(merger);
+
+				ThresholdTemplate template = merger.getThresholdTemplate();
+				return template;
+			} catch (Exception e) {
+				Cat.logError(e);
+			}
+		}
+		return baseTemplate;
+	}
+
+	private void refreshExceptionRules() {
+		synchronized (m_exceptionRules) {
+			try {
+				AlarmTemplate alarmTemplate = m_alarmTemplateDao.findAlarmTemplateByName("exception",
+				      AlarmTemplateEntity.READSET_FULL);
+				int templateId = alarmTemplate.getId();
+				String content = alarmTemplate.getContent();
+				ThresholdTemplate baseTemplate = DefaultSaxParser.parse(content);
+
+				List<AlarmRule> exceptionRules = m_alarmRuleDao.findAllAlarmRuleByTemplateId(templateId,
+				      AlarmRuleEntity.READSET_FULL);
+
+				Set<Integer> allIds = new HashSet<Integer>();
+				for (AlarmRule alarmRule : exceptionRules) {
+					int id = alarmRule.getId();
+					allIds.add(id);
+					Date date = m_exceptionModifyTimes.get(id);
+					if (date == null) {
+						String newContent = alarmRule.getContent();
+						ThresholdTemplate template = mergerTemplate(baseTemplate, newContent);
+
+						addExceptionRule(alarmRule, template);
+						Cat.getProducer().logEvent("ExceptionRule", "Add", Event.SUCCESS, null);
+					} else {
+						Date modifyDate = alarmRule.getModifyDate();
+
+						if (date.getTime() < modifyDate.getTime()) {
+							Cat.getProducer().logEvent("ExceptionRule", "Update", Event.SUCCESS, null);
+							String newContent = alarmRule.getContent();
+							ThresholdTemplate template = mergerTemplate(baseTemplate, newContent);
+
+							String domain = alarmRule.getDomain();
+							ArrayList<ThresholdRule> ruleList = m_exceptionRules.get(domain);
+							for (ThresholdRule rule : ruleList) {
+								if (rule.getRuleId() == alarmRule.getId()) {
+									rule.refreshTemplate(template);
+									m_exceptionModifyTimes.put(rule.getRuleId(), modifyDate);
+									break;
+
+								}
+							}
+						}
+					}
+				}
+
+				for (ArrayList<ThresholdRule> rules : m_exceptionRules.values()) {
+					List<ThresholdRule> removes = new ArrayList<ThresholdRule>();
+
+					for (ThresholdRule rule : rules) {
+						int id = rule.getRuleId();
+
+						if (!allIds.contains(id)) {
+							removes.add(rule);
+						}
+					}
+					for (ThresholdRule rule : removes) {
+						rules.remove(rule);
+						m_exceptionModifyTimes.remove(rule.getRuleId());
+						Cat.getProducer().logEvent("ExceptionRule", "Delete", Event.SUCCESS, null);
+					}
+				}
+			} catch (Exception e) {
+				Cat.logError(e);
+			}
+		}
+	}
+
+	private void refreshServiceRules() {
+		synchronized (m_serviceRules) {
+			try {
+				AlarmTemplate alarmTemplate = m_alarmTemplateDao.findAlarmTemplateByName("service",
+				      AlarmTemplateEntity.READSET_FULL);
+				int templateId = alarmTemplate.getId();
+				String content = alarmTemplate.getContent();
+				ThresholdTemplate baseTemplate = DefaultSaxParser.parse(content);
+
+				List<AlarmRule> serviceRules = m_alarmRuleDao.findAllAlarmRuleByTemplateId(templateId,
+				      AlarmRuleEntity.READSET_FULL);
+
+				Set<Integer> allIds = new HashSet<Integer>();
+				for (AlarmRule alarmRule : serviceRules) {
+					int id = alarmRule.getId();
+					allIds.add(id);
+					Date date = m_serviceModifyTimes.get(id);
+					if (date == null) {
+						String newContent = alarmRule.getContent();
+						ThresholdTemplate template = mergerTemplate(baseTemplate, newContent);
+
+						addServiceRule(alarmRule, template);
+						Cat.getProducer().logEvent("ServiceRule", "Add", Event.SUCCESS, null);
+					} else {
+						Date modifyDate = alarmRule.getModifyDate();
+
+						if (date.getTime() < modifyDate.getTime()) {
+							Cat.getProducer().logEvent("ServiceRule", "Update", Event.SUCCESS, null);
+							String newContent = alarmRule.getContent();
+							ThresholdTemplate template = mergerTemplate(baseTemplate, newContent);
+
+							String domain = alarmRule.getDomain();
+							ArrayList<ThresholdRule> ruleList = m_serviceRules.get(domain);
+							for (ThresholdRule rule : ruleList) {
+								if (rule.getRuleId() == alarmRule.getId()) {
+									rule.refreshTemplate(template);
+									m_serviceModifyTimes.put(rule.getRuleId(), modifyDate);
+									break;
+
+								}
+							}
+						}
+					}
+				}
+
+				for (ArrayList<ThresholdRule> rules : m_serviceRules.values()) {
+					List<ThresholdRule> removes = new ArrayList<ThresholdRule>();
+
+					for (ThresholdRule rule : rules) {
+						int id = rule.getRuleId();
+
+						if (!allIds.contains(id)) {
+							removes.add(rule);
+						}
+					}
+					for (ThresholdRule rule : removes) {
+						rules.remove(rule);
+						m_serviceModifyTimes.remove(rule.getRuleId());
+						Cat.getProducer().logEvent("ServiceRule", "Delete", Event.SUCCESS, null);
+					}
+				}
+			} catch (Exception e) {
+				Cat.logError(e);
+			}
+		}
+	}
+
+	public class ReloadThresholdRuleTask implements Task {
+
+		@Override
+		public String getName() {
+			return "exception-reload-rule";
+		}
+
+		@Override
+		public void run() {
+			boolean active = true;
+
+			while (active) {
+				Transaction t = Cat.newTransaction("System", "RefreshRule");
+
+				t.setStatus(Transaction.SUCCESS);
+				try {
+					refreshExceptionRules();
+					refreshServiceRules();
+				} catch (Exception e) {
+					t.setStatus(e);
+					Cat.logError(e);
+				} finally {
+					t.complete();
+				}
+
+				try {
+					Thread.sleep(10 * 60 * 1000);
+				} catch (Exception e) {
+					active = false;
+				}
+			}
+		}
+
+		@Override
+		public void shutdown() {
+		}
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/event/ExceptionDataEvent.java → cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/event/ExceptionDataEvent.java

-package com.dianping.cat.system.alarm.exception.event;
+package com.dianping.cat.system.alarm.threshold.event;
 
-import com.dianping.cat.system.alarm.exception.ExceptionDataEntity;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
 import com.dianping.cat.system.event.Event;
 import com.dianping.cat.system.event.EventType;
 
 public class ExceptionDataEvent implements Event {
 
-	private ExceptionDataEntity m_data;
+	private ThresholdDataEntity m_data;
 
-	public ExceptionDataEntity getData() {
+	public ExceptionDataEvent(ThresholdDataEntity data) {
+		m_data = data;
+	}
+
+	public ThresholdDataEntity getData() {
 		return m_data;
 	}
 
-	public void setData(ExceptionDataEntity data) {
+	public void setData(ThresholdDataEntity data) {
 		m_data = data;
 	}
 
@@ -21,4 +25,11 @@ public class ExceptionDataEvent implements Event {
 		return EventType.ExceptionDataEvent;
 	}
 
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("Exception: ").append(m_data.toString());
+		return sb.toString();
+	}
+
 }

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/event/ServiceDataEvent.java

+package com.dianping.cat.system.alarm.threshold.event;
+
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
+import com.dianping.cat.system.event.Event;
+import com.dianping.cat.system.event.EventType;
+
+public class ServiceDataEvent implements Event {
+
+	private ThresholdDataEntity m_data;
+
+	public ServiceDataEvent(ThresholdDataEntity data) {
+		m_data = data;
+	}
+
+	public ThresholdDataEntity getData() {
+		return m_data;
+	}
+
+	public void setData(ThresholdDataEntity data) {
+		m_data = data;
+	}
+
+	@Override
+	public EventType getEventType() {
+		return EventType.ServiceDataEvent;
+	}
+
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("Service: ").append(m_data.toString());
+		return sb.toString();
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/exception/event/ExceptionAlertEvent.java → cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/event/ThresholdAlertEvent.java

-package com.dianping.cat.system.alarm.exception.event;
+package com.dianping.cat.system.alarm.threshold.event;
 
+import com.dianping.cat.system.alarm.threshold.template.ThresholdAlarmMeta;
 import com.dianping.cat.system.event.Event;
 import com.dianping.cat.system.event.EventType;
 
-public class ExceptionAlertEvent implements Event {
+public class ThresholdAlertEvent implements Event {
 
-	private int m_ruleId;
+	private ThresholdAlarmMeta m_alarmMeta;
 
-	private String m_ruleType;
-
-	public String getRuleType() {
-		return m_ruleType;
-	}
-
-	public void setRuleType(String ruleType) {
-		m_ruleType = ruleType;
-	}
-
-	public int getRuleId() {
-		return m_ruleId;
+	public ThresholdAlertEvent(ThresholdAlarmMeta alarmMeta) {
+		m_alarmMeta = alarmMeta;
 	}
 
-	public void setRuleId(int ruleId) {
-		m_ruleId = ruleId;
+	public ThresholdAlarmMeta getAlarmMeta() {
+		return m_alarmMeta;
 	}
 
 	@Override

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/listener/ExceptionDataListener.java

+package com.dianping.cat.system.alarm.threshold.listener;
+
+import java.util.List;
+
+import com.dianping.cat.Cat;
+import com.dianping.cat.message.Transaction;
+import com.dianping.cat.system.alarm.alert.AlertInfo;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
+import com.dianping.cat.system.alarm.threshold.ThresholdRule;
+import com.dianping.cat.system.alarm.threshold.ThresholdRuleManager;
+import com.dianping.cat.system.alarm.threshold.event.ThresholdAlertEvent;
+import com.dianping.cat.system.alarm.threshold.event.ExceptionDataEvent;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdAlarmMeta;
+import com.dianping.cat.system.event.Event;
+import com.dianping.cat.system.event.EventDispatcher;
+import com.dianping.cat.system.event.EventListener;
+import com.dianping.cat.system.event.EventType;
+import com.site.lookup.annotation.Inject;
+
+public class ExceptionDataListener implements EventListener {
+
+	@Inject
+	private EventDispatcher m_dispatcher;
+
+	@Inject
+	private ThresholdRuleManager m_manager;
+
+	@Override
+	public boolean isEligible(Event event) {
+		if (event.getEventType() == EventType.ExceptionDataEvent) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public void onEvent(Event event) {
+		ExceptionDataEvent dataEvent = (ExceptionDataEvent) event;
+
+		ThresholdDataEntity data = dataEvent.getData();
+		List<ThresholdRule> rules = m_manager.getExceptionRuleByDomain(data.getDomain());
+
+		for (ThresholdRule rule : rules) {
+			ThresholdAlarmMeta alarmMeta = rule.addData(data,AlertInfo.EXCEPTION);
+
+			if (alarmMeta != null) {
+				Transaction t = Cat.newTransaction("SendAlarm", "Exception");
+				t.addData(alarmMeta.toString());
+	
+				try {
+	            ThresholdAlertEvent alertEvent = new ThresholdAlertEvent(alarmMeta);
+	           
+	            m_dispatcher.dispatch(alertEvent);
+	            t.setStatus(Transaction.SUCCESS);
+            } catch (Exception e) {
+            	t.setStatus(e);
+            }finally{
+            	t.complete();
+            }
+			}
+		}
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/listener/ServiceDataListener.java

+package com.dianping.cat.system.alarm.threshold.listener;
+
+import java.util.List;
+
+import com.dianping.cat.Cat;
+import com.dianping.cat.message.Transaction;
+import com.dianping.cat.system.alarm.alert.AlertInfo;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
+import com.dianping.cat.system.alarm.threshold.ThresholdRule;
+import com.dianping.cat.system.alarm.threshold.ThresholdRuleManager;
+import com.dianping.cat.system.alarm.threshold.event.ServiceDataEvent;
+import com.dianping.cat.system.alarm.threshold.event.ThresholdAlertEvent;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdAlarmMeta;
+import com.dianping.cat.system.event.Event;
+import com.dianping.cat.system.event.EventDispatcher;
+import com.dianping.cat.system.event.EventListener;
+import com.dianping.cat.system.event.EventType;
+import com.site.lookup.annotation.Inject;
+
+public class ServiceDataListener implements EventListener {
+
+	@Inject
+	private EventDispatcher m_dispatcher;
+
+	@Inject
+	private ThresholdRuleManager m_manager;
+
+	@Override
+	public boolean isEligible(Event event) {
+		if (event.getEventType() == EventType.ServiceDataEvent) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public void onEvent(Event event) {
+		ServiceDataEvent dataEvent = (ServiceDataEvent) event;
+
+		ThresholdDataEntity data = dataEvent.getData();
+		List<ThresholdRule> rules = m_manager.getServiceRuleByDomain(data.getDomain());
+
+		for (ThresholdRule rule : rules) {
+			ThresholdAlarmMeta alarmMeta = rule.addData(data, AlertInfo.SERVICE);
+
+			if (alarmMeta != null) {
+				Transaction t = Cat.newTransaction("SendAlarm", "Service");
+				t.addData(alarmMeta.toString());
+
+				try {
+					ThresholdAlertEvent alertEvent = new ThresholdAlertEvent(alarmMeta);
+
+					m_dispatcher.dispatch(alertEvent);
+					t.setStatus(Transaction.SUCCESS);
+				} catch (Exception e) {
+					t.setStatus(e);
+				} finally {
+					t.complete();
+				}
+			}
+		}
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/listener/ThresholdAlertListener.java

+package com.dianping.cat.system.alarm.threshold.listener;
+
+import java.io.StringWriter;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
+import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
+
+import com.dianping.cat.Cat;
+import com.dianping.cat.helper.CatString;
+import com.dianping.cat.helper.TimeUtil;
+import com.dianping.cat.system.alarm.alert.AlertInfo;
+import com.dianping.cat.system.alarm.alert.AlertManager;
+import com.dianping.cat.system.alarm.threshold.event.ThresholdAlertEvent;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdAlarmMeta;
+import com.dianping.cat.system.event.Event;
+import com.dianping.cat.system.event.EventListener;
+import com.dianping.cat.system.event.EventType;
+import com.dianping.cat.system.notify.ReportRenderImpl;
+import com.dianping.cat.system.page.alarm.RuleManager;
+import com.site.lookup.annotation.Inject;
+
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+
+public class ThresholdAlertListener implements EventListener, Initializable {
+	@Inject
+	private AlertManager m_alarmManager;
+
+	public Configuration m_configuration;
+
+	@Inject
+	private RuleManager m_ruleManager;
+
+	private String buildAlarmContent(ThresholdAlarmMeta meta) {
+		Map<Object, Object> root = new HashMap<Object, Object>();
+		StringWriter sw = new StringWriter(5000);
+
+		root.put("domain", meta.getDomain());
+		root.put("date", meta.getDate());
+		root.put("url", buildProblemUrl(meta.getBaseUrl(), meta.getDomain(), meta.getDate()));
+		try {
+			String type = meta.getType();
+
+			if (type.equalsIgnoreCase(AlertInfo.EXCEPTION)) {
+				Template t = m_configuration.getTemplate("exceptionAlarm.ftl");
+
+				t.process(root, sw);
+			} else if (type.equalsIgnoreCase(AlertInfo.SERVICE)) {
+				Template t = m_configuration.getTemplate("serviceAlarm.ftl");
+
+				t.process(root, sw);
+			}
+		} catch (Exception e) {
+			Cat.logError(e);
+		}
+		return sw.toString();
+	}
+
+	private String buildAlarmTitle(ThresholdAlarmMeta meta) {
+		String type = meta.getType();
+
+		if (type.equalsIgnoreCase(AlertInfo.EXCEPTION)) {
+			return String.valueOf(meta.getDomain()) + CatString.EXCEPTION;
+		} else {
+			return String.valueOf(meta.getDomain()) + CatString.SERVICE;
+		}
+	}
+
+	private String buildProblemUrl(String baseUrl, String domain, Date date) {
+		long time = date.getTime();
+
+		time = time - time % TimeUtil.ONE_HOUR;
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHH");
+
+		baseUrl = baseUrl.replaceAll("dashboard", "p");
+		StringBuilder sb = new StringBuilder(baseUrl);
+
+		sb.append("?").append("domain=").append(domain).append("&date=").append(sdf.format(new Date(time)));
+		return sb.toString();
+	}
+
+	@Override
+	public void initialize() throws InitializationException {
+		m_configuration = new Configuration();
+		m_configuration.setDefaultEncoding("UTF-8");
+		try {
+			m_configuration.setClassForTemplateLoading(ReportRenderImpl.class, "/freemaker");
+		} catch (Exception e) {
+			Cat.logError(e);
+		}
+	}
+
+	@Override
+	public boolean isEligible(Event event) {
+		if (event.getEventType() == EventType.ExceptionAlertEvent) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public void onEvent(Event event) {
+		ThresholdAlertEvent alertEvent = (ThresholdAlertEvent) event;
+
+		ThresholdAlarmMeta meta = alertEvent.getAlarmMeta();
+		String title = buildAlarmTitle(meta);
+		String content = buildAlarmContent(meta);
+		String alarmType = meta.getDuration().getAlarm().toLowerCase();
+
+		if (alarmType != null && alarmType.length() > 0) {
+			String[] types = alarmType.split(",");
+
+			for (String type : types) {
+				if (type.equalsIgnoreCase(AlertInfo.EMAIL)) {
+					List<String> address = m_ruleManager.queryUserMailsByRuleId(meta.getRuleId());
+
+					m_alarmManager.addAlarmInfo(AlertInfo.EMAIL_TYPE, title, content, address, meta.getRuleId(),
+					      meta.getDate());
+
+				} else if (type.equalsIgnoreCase(AlertInfo.SMS)) {
+					List<String> address = m_ruleManager.queryUserPhonesByRuleId(meta.getRuleId());
+
+					m_alarmManager.addAlarmInfo(AlertInfo.SMS_TYPE, title, content, address, meta.getRuleId(),
+					      meta.getDate());
+				}
+			}
+		}
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/template/ThresholdAlarmMeta.java

+package com.dianping.cat.system.alarm.threshold.template;
+
+import java.util.Date;
+
+import com.dianping.cat.home.template.entity.Duration;
+
+public class ThresholdAlarmMeta {
+	private String m_baseUrl;
+
+	private Date m_date;
+
+	private String m_domain;
+
+	private Duration m_duration;
+
+	private long m_realCount;
+
+	private int m_ruleId;
+
+	private String m_type;
+
+	public String getBaseUrl() {
+		return m_baseUrl;
+	}
+
+	public Date getDate() {
+		return m_date;
+	}
+
+	public String getDomain() {
+		return m_domain;
+	}
+
+	public Duration getDuration() {
+		return m_duration;
+	}
+
+	public long getRealCount() {
+		return m_realCount;
+	}
+
+	public int getRuleId() {
+		return m_ruleId;
+	}
+
+	public String getType() {
+		return m_type;
+	}
+
+	public void setBaseUrl(String baseUrl) {
+		m_baseUrl = baseUrl;
+	}
+
+	public ThresholdAlarmMeta setDate(Date date) {
+		m_date = date;
+		return this;
+	}
+
+	public ThresholdAlarmMeta setDomain(String domain) {
+		m_domain = domain;
+		return this;
+	}
+
+	public ThresholdAlarmMeta setDuration(Duration duration) {
+		m_duration = duration;
+		return this;
+	}
+
+	public ThresholdAlarmMeta setRealCount(long realCount) {
+		m_realCount = realCount;
+		return this;
+	}
+
+	public ThresholdAlarmMeta setRuleId(int ruleId) {
+		m_ruleId = ruleId;
+		return this;
+	}
+
+	public ThresholdAlarmMeta setType(String type) {
+		m_type = type;
+		return this;
+	}
+
+	public String toString() {
+		StringBuilder sb = new StringBuilder(400);
+
+		sb.append('[').append("RuleId:").append(m_ruleId).append(";");
+		sb.append("Type:").append(m_type).append(";");
+		sb.append("RealCount:").append(m_realCount).append(";");
+		sb.append("Duration:").append(m_duration).append(']');
+
+		return sb.toString();
+	}
+}

cat-home/src/main/java/com/dianping/cat/system/alarm/threshold/template/ThresholdTemplateMerger.java

+package com.dianping.cat.system.alarm.threshold.template;
+
+import com.dianping.cat.home.template.entity.Duration;
+import com.dianping.cat.home.template.entity.Param;
+import com.dianping.cat.home.template.entity.ThresholdTemplate;
+import com.dianping.cat.home.template.transform.DefaultMerger;
+
+public class ThresholdTemplateMerger extends DefaultMerger {
+
+	public ThresholdTemplateMerger(ThresholdTemplate thresholdTemplate) {
+		super(thresholdTemplate);
+	}
+
+	@Override
+	protected void mergeDuration(Duration old, Duration duration) {
+		old.setMin(duration.getMin());
+		old.setMax(duration.getMax());
+		old.setInterval(duration.getInterval());
+		old.setAlarm(duration.getAlarm());
+		old.setId(duration.getId());
+		old.setAlarmInterval(duration.getAlarmInterval());
+	}
+
+	@Override
+	protected void mergeParam(Param old, Param param) {
+		old.setValue(param.getValue());
+		old.setType(param.getType());
+	}
+
+}

cat-home/src/main/java/com/dianping/cat/system/event/EventType.java

@@ -6,4 +6,8 @@ public enum EventType {
 
 	ExceptionAlertEvent,
 
+	ServiceDataEvent,
+
+	ServiceAlertEvent,
+
 }

cat-home/src/main/java/com/dianping/cat/system/notify/ScheduledMailTask.java

@@ -113,7 +113,9 @@ public class ScheduledMailTask implements Task {
 
 	@Override
 	public void run() {
-		while (true) {
+		boolean active = true;
+
+		while (active) {
 			try {
 				MailRecord mailRecord = null;
 				try {
@@ -157,7 +159,7 @@ public class ScheduledMailTask implements Task {
 			try {
 				Thread.sleep(getSleepTime());
 			} catch (Exception e) {
-				// ignore;
+				active = false;
 			}
 		}
 

cat-home/src/main/java/com/dianping/cat/system/page/alarm/RuleManager.java

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import com.dainping.cat.home.dal.user.DpAdminLogin;
+import com.dainping.cat.home.dal.user.DpAdminLoginDao;
+import com.dainping.cat.home.dal.user.DpAdminLoginEntity;
 import com.dianping.cat.Cat;
 import com.dianping.cat.home.dal.alarm.AlarmRule;
 import com.dianping.cat.home.dal.alarm.AlarmRuleDao;
@@ -20,17 +23,20 @@ import com.site.dal.jdbc.DalNotFoundException;
 import com.site.lookup.annotation.Inject;
 
 public class RuleManager {
-	
+
 	@Inject
 	private AlarmRuleDao m_alarmRuleDao;
-	
+
 	@Inject
 	private AlarmRuleSubscriptionDao m_alarmRuleSubscriptionDao;
-	
+
 	@Inject
 	private AlarmTemplateDao m_alarmTemplateDao;
-	
-	public void queryExceptionRuleList(Model model,int userId) {
+
+	@Inject
+	private DpAdminLoginDao m_dpAdminLoginDao;
+
+	public void queryExceptionRuleList(Model model, int userId) {
 		List<UserAlarmSubState> userRules = new ArrayList<UserAlarmSubState>();
 		try {
 			int templateId = queryTemplateByName("exception").getId();
@@ -53,11 +59,11 @@ public class RuleManager {
 		} catch (DalException e) {
 			Cat.logError(e);
 		}
-		Collections.sort(userRules,new UserAlarmSubStateCompartor());
+		Collections.sort(userRules, new UserAlarmSubStateCompartor());
 		model.setUserSubStates(userRules);
 	}
 
-	public void queryServiceRuleList(Model model,int userId) {
+	public void queryServiceRuleList(Model model, int userId) {
 		List<UserAlarmSubState> userRules = new ArrayList<UserAlarmSubState>();
 		try {
 			int templateId = queryTemplateByName("service").getId();
@@ -80,7 +86,7 @@ public class RuleManager {
 		} catch (DalException e) {
 			Cat.logError(e);
 		}
-		Collections.sort(userRules,new UserAlarmSubStateCompartor());
+		Collections.sort(userRules, new UserAlarmSubStateCompartor());
 		model.setUserSubStates(userRules);
 	}
 
@@ -97,6 +103,51 @@ public class RuleManager {
 		throw new RuntimeException("Template Can't be null!");
 	}
 
+	public List<String> queryUserMailsByRuleId(int alarmRuleId) {
+		List<String> mails = new ArrayList<String>();
+		try {
+			List<AlarmRuleSubscription> alarmRuleSubscriptions = m_alarmRuleSubscriptionDao.findByAlarmRuleId(alarmRuleId,
+			      AlarmRuleSubscriptionEntity.READSET_FULL);
+
+			for (AlarmRuleSubscription alarmRule : alarmRuleSubscriptions) {
+				int userId = alarmRule.getUserId();
+
+				try {
+					DpAdminLogin entity = m_dpAdminLoginDao.findByPK(userId, DpAdminLoginEntity.READSET_FULL);
+					mails.add(entity.getEmail());
+				} catch (Exception e) {
+				}
+			}
+		} catch (DalNotFoundException e) {
+		} catch (Exception e) {
+			Cat.logError(e);
+		}
+		return mails;
+	}
+
+	public List<String> queryUserPhonesByRuleId(int alarmRuleId) {
+		List<String> phones = new ArrayList<String>();
+		try {
+			List<AlarmRuleSubscription> alarmRuleSubscriptions = m_alarmRuleSubscriptionDao.findByAlarmRuleId(alarmRuleId,
+			      AlarmRuleSubscriptionEntity.READSET_FULL);
+
+			for (AlarmRuleSubscription alarmRule : alarmRuleSubscriptions) {
+				int userId = alarmRule.getUserId();
+
+				try {
+					DpAdminLogin entity = m_dpAdminLoginDao.findByPK(userId, DpAdminLoginEntity.READSET_FULL);
+					// TODO
+					phones.add(entity.getEmail());
+				} catch (Exception e) {
+				}
+			}
+		} catch (DalNotFoundException e) {
+		} catch (Exception e) {
+			Cat.logError(e);
+		}
+		return phones;
+	}
+
 	public void ruleAdd(Payload payload, Model model) {
 		List<String> domains = new ArrayList<String>();
 
@@ -135,8 +186,8 @@ public class RuleManager {
 			Cat.logError(e);
 		}
 	}
-	
-	public void ruleSub(Payload payload,int loginId) {
+
+	public void ruleSub(Payload payload, int loginId) {
 		int subState = payload.getUserSubState();
 		int alarmRuleId = payload.getAlarmRuleId();
 
@@ -168,6 +219,7 @@ public class RuleManager {
 			Cat.logError(e);
 		}
 	}
+
 	public void ruleUpdateSubmit(Payload payload, Model model) {
 		int id = payload.getAlarmRuleId();
 		String content = payload.getContent();

cat-home/src/main/resources/META-INF/dal/jdbc/alarm-dal.xml

@@ -28,6 +28,11 @@
 				<statement><![CDATA[SELECT <FIELDS/> FROM <TABLE/> WHERE <FIELD name='user-id'/> = ${user-id}
 				]]></statement>
 			</query>
+			<query name="find-by-alarm-rule-id" type="SELECT" multiple="true">
+				<param name="alarm-rule-id" />
+				<statement><![CDATA[SELECT <FIELDS/> FROM <TABLE/> WHERE <FIELD name='alarm-rule-id'/> = ${alarm-rule-id}
+				]]></statement>
+			</query>
 		</query-defs>
 	</entity>
 	<entity name="alarm-rule" table="alarmRule" alias="a2">

cat-home/src/main/resources/META-INF/dal/model/threshold-template-codegen.xml

@@ -2,7 +2,6 @@
 <model>
   <entity name="threshold-template" root="true">
     <entity-ref name="connection" />
-    <entity-ref name="threshold" />
   </entity>
   <entity name="connection">
     <attribute name="baseUrl" value-type="String" />
@@ -12,10 +11,6 @@
     <attribute name="type" value-type="String" key="true"/>
     <attribute name="value" value-type="String" />
   </entity>
-  <entity name="threshold">
-    <attribute name="period" value-type="int" />
-    <entity-ref name="duration" type="list" names="durations" />
-  </entity>
   <entity name="duration">
     <attribute name="id" value-type="String" />
     <attribute name="min" value-type="int" />

cat-home/src/main/resources/META-INF/dal/model/threshold-template-model.xml

@@ -3,7 +3,6 @@
 	enable-xml-parser="true"  enable-sax-parser="true" enable-json-parser="true" enable-base-visitor="true">
 	<entity name="threshold-template" root="true">
     <entity-ref name="connection" />
-    <entity-ref name="threshold" />
     <entity-ref name="duration" type="map" names="durations" method-find-or-create="true" />
   </entity>
   <entity name="connection">
@@ -19,6 +18,7 @@
     <attribute name="min" value-type="int" />
     <attribute name="max" value-type="int" />
     <attribute name="interval" value-type="int" />
+    <attribute name="alarm-interval" value-type="int" />
   </entity>
 </model>
 

cat-home/src/main/resources/META-INF/plexus/components.xml

@@ -2382,6 +2382,9 @@
 				<requirement>
 					<role>com.dianping.cat.home.dal.alarm.AlarmTemplateDao</role>
 				</requirement>
+				<requirement>
+					<role>com.dainping.cat.home.dal.user.DpAdminLoginDao</role>
+				</requirement>
 			</requirements>
 		</component>
 		<component>
@@ -2402,6 +2405,15 @@
 				</requirement>
 			</requirements>
 		</component>
+		<component>
+			<role>com.dainping.cat.home.dal.user.DpAdminLoginDao</role>
+			<implementation>com.dainping.cat.home.dal.user.DpAdminLoginDao</implementation>
+			<requirements>
+				<requirement>
+					<role>com.site.dal.jdbc.QueryEngine</role>
+				</requirement>
+			</requirements>
+		</component>
 		<component>
 			<role>com.dianping.cat.system.page.alarm.TemplateManager</role>
 			<implementation>com.dianping.cat.system.page.alarm.TemplateManager</implementation>
@@ -2435,15 +2447,6 @@
 				</requirement>
 			</requirements>
 		</component>
-		<component>
-			<role>com.dainping.cat.home.dal.user.DpAdminLoginDao</role>
-			<implementation>com.dainping.cat.home.dal.user.DpAdminLoginDao</implementation>
-			<requirements>
-				<requirement>
-					<role>com.site.dal.jdbc.QueryEngine</role>
-				</requirement>
-			</requirements>
-		</component>
 		<component>
 			<role>com.dianping.cat.system.page.login.Handler</role>
 			<implementation>com.dianping.cat.system.page.login.Handler</implementation>
@@ -2502,8 +2505,8 @@
 			</requirements>
 		</component>
 		<component>
-			<role>com.dianping.cat.system.alarm.DefaultAlarmCreator</role>
-			<implementation>com.dianping.cat.system.alarm.DefaultAlarmCreator</implementation>
+			<role>com.dianping.cat.system.alarm.AlarmRuleCreator</role>
+			<implementation>com.dianping.cat.system.alarm.AlarmRuleCreator</implementation>
 			<requirements>
 				<requirement>
 					<role>com.dianping.cat.home.dal.alarm.AlarmRuleDao</role>
@@ -2563,30 +2566,79 @@
 			</requirements>
 		</component>
 		<component>
-			<role>com.dianping.cat.system.alarm.exception.listener.ExceptionAlertListener</role>
-			<implementation>com.dianping.cat.system.alarm.exception.listener.ExceptionAlertListener</implementation>
+			<role>com.dianping.cat.system.alarm.connector.Connector</role>
+			<implementation>com.dianping.cat.system.alarm.connector.impl.ThresholdConnector</implementation>
+		</component>
+		<component>
+			<role>com.dianping.cat.system.alarm.alert.AlertManager</role>
+			<implementation>com.dianping.cat.system.alarm.alert.AlertManager</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.home.dal.alarm.MailRecordDao</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.system.alarm.threshold.ThresholdRuleManager</role>
+			<implementation>com.dianping.cat.system.alarm.threshold.ThresholdRuleManager</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.home.dal.alarm.AlarmTemplateDao</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.home.dal.alarm.AlarmRuleDao</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.system.alarm.threshold.listener.ExceptionDataListener</role>
+			<implementation>com.dianping.cat.system.alarm.threshold.listener.ExceptionDataListener</implementation>
 			<requirements>
 				<requirement>
 					<role>com.dianping.cat.system.event.EventDispatcher</role>
 				</requirement>
+				<requirement>
+					<role>com.dianping.cat.system.alarm.threshold.ThresholdRuleManager</role>
+				</requirement>
 			</requirements>
 		</component>
 		<component>
-			<role>com.dianping.cat.system.alarm.exception.listener.ExceptionDataListener</role>
-			<implementation>com.dianping.cat.system.alarm.exception.listener.ExceptionDataListener</implementation>
+			<role>com.dianping.cat.system.alarm.threshold.listener.ServiceDataListener</role>
+			<implementation>com.dianping.cat.system.alarm.threshold.listener.ServiceDataListener</implementation>
 			<requirements>
 				<requirement>
 					<role>com.dianping.cat.system.event.EventDispatcher</role>
 				</requirement>
+				<requirement>
+					<role>com.dianping.cat.system.alarm.threshold.ThresholdRuleManager</role>
+				</requirement>
+			</requirements>
+		</component>
+		<component>
+			<role>com.dianping.cat.system.alarm.threshold.listener.ThresholdAlertListener</role>
+			<implementation>com.dianping.cat.system.alarm.threshold.listener.ThresholdAlertListener</implementation>
+			<requirements>
+				<requirement>
+					<role>com.dianping.cat.system.alarm.alert.AlertManager</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.system.page.alarm.RuleManager</role>
+				</requirement>
 			</requirements>
 		</component>
 		<component>
-			<role>com.dianping.cat.system.alarm.ExceptionAlarmTask</role>
-			<implementation>com.dianping.cat.system.alarm.ExceptionAlarmTask</implementation>
+			<role>com.dianping.cat.system.alarm.AlarmTask</role>
+			<implementation>com.dianping.cat.system.alarm.AlarmTask</implementation>
 			<requirements>
 				<requirement>
 					<role>com.dianping.cat.system.event.EventDispatcher</role>
 				</requirement>
+				<requirement>
+					<role>com.dianping.cat.system.alarm.connector.Connector</role>
+				</requirement>
+				<requirement>
+					<role>com.dianping.cat.system.alarm.threshold.ThresholdRuleManager</role>
+				</requirement>
 			</requirements>
 		</component>
 	</components>

cat-home/src/main/resources/freemaker/exceptionAlarm.ftl

+<h4>异常超过阀值告警</h4>
+<table rules="all">
+	<tr>
+	</tr>
+	<tr>
+		<td></td>
+		<td>项目名称</td>
+		<td>${domain}</td>
+		<td></td>
+	</tr>
+	<tr>
+		<td></td>
+		<td>告警时间</td>
+		<td>${date?string("yyyy-MM-dd HH:mm:ss")}</td>
+		<td></td>
+	</tr>
+	<tr>
+		<td></td>
+		<td>CAT链接</td>
+		<td> <a href="${url}" target="_blank">link</a></td>
+		<td></td>
+	</tr>
+	<tr></tr>
+</table>
\ No newline at end of file

cat-home/src/main/resources/freemaker/serviceAlarm.ftl

+<h4>服务调用失败告警</h4>
+<table rules="all">
+	<tr>
+	</tr>
+	<tr>
+		<td></td>
+		<td>项目名称</td>
+		<td>${domain}</td>
+		<td></td>
+	</tr>
+	<tr>
+		<td></td>
+		<td>告警时间</td>
+		<td>${date?string("yyyy-MM-dd HH:mm:ss")}</td>
+		<td></td>
+	</tr>
+	<tr>
+		<td></td>
+		<td>CAT链接</td>
+		<td> <a href="${url}" target="_blank">link</a></td>
+		<td></td>
+	</tr>
+	<tr></tr>
+</table>
\ No newline at end of file

cat-home/src/main/webapp/jsp/system/alarmTemplateList.jsp

@@ -28,7 +28,11 @@
 			<table>
 				<tr><td><a href="?op=alarmTemplateUpdate&alarmTemplateId=${model.alarmTemplate.id}" target="_blank">修改</a></td></tr>
 				<tr><td>模板名称</td><td>${model.alarmTemplate.name}</td></tr>
-				<tr><td>模板内容</td><td>${model.alarmTemplate.content}</td></tr>
+				<tr><td>模板内容</td>
+					<td>
+						<textarea style="height:500px;width:500px" id="content" name="content">${model.alarmTemplate.content}</textarea>
+					</td>
+					</tr>
 			</table>
 		</div>
 	</div>

cat-home/src/test/java/com/dianping/cat/AllTests.java

@@ -32,6 +32,8 @@ import com.dianping.cat.report.task.problem.ProblemGraphCreatorTest;
 import com.dianping.cat.report.task.transaction.HistoryTransactionMergerTest;
 import com.dianping.cat.report.task.transaction.TransactionDailyGraphMergerTest;
 import com.dianping.cat.report.task.transaction.TransactionGraphCreatorTest;
+import com.dianping.cat.system.alarm.template.TemplateMergerTest;
+import com.dianping.cat.system.alarm.template.ThresholdRuleTest;
 import com.dianping.cat.system.notify.RenderTest;
 
 @RunWith(Suite.class)
@@ -80,7 +82,7 @@ import com.dianping.cat.system.notify.RenderTest;
 
       /* .report.task */
       TaskConsumerTest.class, TaskHelperTest.class,
-      
+
       /* .health report */
       HealthReportBuilderTest.class,
 
@@ -91,8 +93,8 @@ import com.dianping.cat.system.notify.RenderTest;
       TransactionGraphCreatorTest.class, EventGraphCreatorTest.class, EventDailyGraphMergerTest.class,
 
       TransactionDailyGraphMergerTest.class, ProblemDailyGraphMergerTest.class,
-      
-		/* .render*/
-      RenderTest.class})
+
+      /* alarm .render */
+      RenderTest.class, ThresholdRuleTest.class, TemplateMergerTest.class })
 public class AllTests {
 }

cat-home/src/test/java/com/dianping/cat/system/alarm/template/TemplateMergerTest.java

@@ -6,6 +6,7 @@ import org.unidal.webres.helper.Files;
 
 import com.dianping.cat.home.template.entity.ThresholdTemplate;
 import com.dianping.cat.home.template.transform.DefaultDomParser;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdTemplateMerger;
 
 
 public class TemplateMergerTest {
@@ -16,12 +17,13 @@ public class TemplateMergerTest {
 		ThresholdTemplate templateOld = new DefaultDomParser().parse(oldXml);
 		ThresholdTemplate templateNew = new DefaultDomParser().parse(newXml);
 		String expected = Files.forIO().readFrom(getClass().getResourceAsStream("threshold-template-mergeResult.xml"), "utf-8");
-		TemplateMerger merger = new TemplateMerger(new ThresholdTemplate());
+		ThresholdTemplateMerger merger = new ThresholdTemplateMerger(new ThresholdTemplate());
 
-		templateOld.accept(merger);
 		templateNew.accept(merger);
+		templateOld.accept(merger);
+		
 		ThresholdTemplate mergeResult = merger.getThresholdTemplate();
-		String resultStr = mergeResult.toString().replaceAll("\\s*", "");
-		Assert.assertEquals("Check the merge result!", expected.replaceAll("\\s*", ""), resultStr);
+		//Assert.assertEquals("Check the merge result!", expected, mergeResult.toString());
+		Assert.assertEquals("Check the merge result!", expected.replaceAll("\\s*", ""), mergeResult.toString().replaceAll("\\s*", ""));
 	}
 }

cat-home/src/test/java/com/dianping/cat/system/alarm/template/ThresholdRuleTest.java

+package com.dianping.cat.system.alarm.template;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import junit.framework.Assert;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.unidal.webres.helper.Files;
+
+import com.dianping.cat.home.template.entity.ThresholdTemplate;
+import com.dianping.cat.home.template.transform.DefaultDomParser;
+import com.dianping.cat.system.alarm.alert.AlertInfo;
+import com.dianping.cat.system.alarm.threshold.ThresholdRule;
+import com.dianping.cat.system.alarm.threshold.ThresholdDataEntity;
+import com.dianping.cat.system.alarm.threshold.template.ThresholdAlarmMeta;
+
+public class ThresholdRuleTest {
+	private ThresholdRule m_rule;
+
+	private Date m_lastDate;
+
+	@Before
+	public void setUp() {
+		try {
+			String oldXml = Files.forIO().readFrom(getClass().getResourceAsStream("threshold-template.xml"), "utf-8");
+			ThresholdTemplate template = new DefaultDomParser().parse(oldXml);
+
+			m_rule = new ThresholdRule(1, "Cat", template);
+		} catch (Exception e) {
+		}
+		List<ThresholdDataEntity> datas = m_rule.getDatas();
+
+		prepareDatas(datas);
+	}
+
+	@Test
+	public void testAddData() throws Exception {
+		ThresholdDataEntity entity = new ThresholdDataEntity();
+
+		entity.setCount(420);
+		entity.setDate(new Date(m_lastDate.getTime() + 10));
+
+		ThresholdAlarmMeta meta = m_rule.addData(entity, AlertInfo.EXCEPTION);
+
+		Assert.assertEquals(240, meta.getRealCount());
+
+		Map<String, Long> lastAlarmTimes = m_rule.getLastAlarmTime();
+		int size = lastAlarmTimes.size();
+		Assert.assertEquals(1, size);
+
+		meta = m_rule.addData(entity, AlertInfo.EXCEPTION);
+		Assert.assertEquals(null, meta);
+	}
+
+	@Test
+	public void testConnectUrl() throws Exception {
+		Assert.assertEquals("http://cat.dianpingoa.com/cat/r/dashboard?report=problem&type=error&domain=Cat",
+		      m_rule.getConnectUrl());
+
+	}
+
+	@Test
+	public void testCleanData() {
+		int maxInterval = m_rule.getMaxInterval();
+		m_rule.cleanData(maxInterval, m_lastDate.getTime());
+
+		List<ThresholdDataEntity> datas = m_rule.getDatas();
+
+		Assert.assertEquals(6, maxInterval);
+		Assert.assertEquals(15, datas.size());
+	}
+
+	@Test
+	public void testGetCount() {
+		long count = m_rule.getCount(5, m_lastDate);
+		Assert.assertEquals(180, count);
+
+		count = m_rule.getCount(4, m_lastDate);
+		Assert.assertEquals(140, count);
+
+		count = m_rule.getCount(3, m_lastDate);
+		Assert.assertEquals(100, count);
+
+		List<ThresholdDataEntity> datas = m_rule.getDatas();
+		int length = datas.size();
+
+		ThresholdDataEntity entity = datas.get(length - 1);
+
+		Date date = entity.getDate();
+		ThresholdDataEntity entity1 = new ThresholdDataEntity();
+		entity1.setCount(10);
+		entity1.setDate(new Date(date.getTime() + 1));
+
+		datas.add(entity1);
+
+		ThresholdDataEntity entity2 = new ThresholdDataEntity();
+		entity2.setCount(50);
+		entity2.setDate(new Date(date.getTime() + 1));
+
+		datas.add(entity2);
+		count = m_rule.getCount(3, m_lastDate);
+		Assert.assertEquals(150, count);
+
+	}
+
+	private void prepareDatas(List<ThresholdDataEntity> datas) {
+		int size = 20;
+		for (int i = 0; i < size; i++) {
+			ThresholdDataEntity entity = new ThresholdDataEntity();
+			entity.setCount((1 + i) * 20);
+
+			Calendar cal = Calendar.getInstance();
+			cal.set(Calendar.MILLISECOND, 0);
+			cal.set(Calendar.MINUTE, -10);
+			cal.add(Calendar.MILLISECOND, 30 * 1000 * i);
+			Date date = cal.getTime();
+			entity.setDate(date);
+			entity.setDomain("Cat");
+
+			datas.add(entity);
+
+			if (i == size - 1) {
+				m_lastDate = date;
+			}
+		}
+	}
+}

cat-home/src/test/resources/com/dianping/cat/system/alarm/template/threshold-template-mergeResult.xml

@@ -3,14 +3,10 @@
 		<param type="name" value="status" />
 		<param type="report" value="problem" />
 		<param type="type" value="heartbeat" />
-		<param type="domain" value="UserService" />
+		<param type="domain" value="MobileApi" />
 	</connection>
-	<threshold period="2">
-		<duration id="duration1" min="-2" max="10" interval="60000"
-			alarm="EMAIL" />
-		<duration id="duration2" min="10" max="30" interval="60000"
-			alarm="SMS" />
-		<duration id="duration3" min="30" max="-1" interval="60000"
-			alarm="EMAIL,SMS" />
-	</threshold>
+	<duration id="duration1" min="-2" max="10" interval="60000" alarm="EMAIL"/>
+	<duration id="duration2" min="-10" max="40" interval="70000" alarm="EMAIL,SMS"/>
+	<duration id="duration3" min="30" max="-1" interval="60000" alarm="EMAIL,SMS" />
+	<duration id="duration4" min="30" max="-1" interval="80000" alarm="EMAIL,SMS"/>
 </threshold-template>

cat-home/src/test/resources/com/dianping/cat/system/alarm/template/threshold-template-new.xml

 <?xml version="1.0" encoding="utf-8"?>
 <threshold-template>
 	<connection baseUrl="http://cat.dianpingoa.com/cat/r/dashboard">
-		<param type="name" value="status"></param>
 		<param type="report" value="problem"></param>
 		<param type="type" value="heartbeat"></param>
 		<param type="domain" value="MobileApi"></param>
 	</connection>
-	<threshold period="2">
-		<duration id="duration1" min="-2" max="10" interval="60000" alarm="EMAIL"/>
-		<duration id="duration2" min="10" max="30" interval="60000" alarm="SMS"/>
-		<duration id="duration3" min="30" max="-1" interval="60000" alarm="EMAIL,SMS"/>
-	</threshold>
+	<duration id="duration1" min="-2" max="10" interval="60000" alarm="EMAIL"/>
+	<duration id="duration2" min="-10" max="40" interval="70000" alarm="EMAIL,SMS"/>
+	<duration id="duration4" min="30" max="-1" interval="80000" alarm="EMAIL,SMS"/>
 </threshold-template>
\ No newline at end of file

cat-home/src/test/resources/com/dianping/cat/system/alarm/template/threshold-template-old.xml

@@ -3,12 +3,8 @@
 	<connection baseUrl="http://cat.dianpingoa.com/cat/r/dashboard">
 		<param type="name" value="status"></param>
 		<param type="report" value="problem"></param>
-		<param type="type" value="heartbeat"></param>
-		<param type="domain" value="UserService"></param>
 	</connection>
-	<threshold period="2">
-		<duration id="duration1" min="-2" max="10" interval="60000" alarm="EMAIL"/>
-		<duration id="duration2" min="10" max="30" interval="60000" alarm="SMS"/>
-		<duration id="duration3" min="30" max="-1" interval="60000" alarm="EMAIL,SMS"/>
-	</threshold>
+	<duration id="duration1" min="-2" max="10" interval="60000" alarm="EMAIL"/>
+	<duration id="duration2" min="10" max="30" interval="60000" alarm="SMS"/>
+	<duration id="duration3" min="30" max="-1" interval="60000" alarm="EMAIL,SMS"/>
 </threshold-template>
\ No newline at end of file

cat-home/src/test/resources/com/dianping/cat/system/alarm/template/threshold-template.xml

+<?xml version="1.0" encoding="utf-8"?>
+<threshold-template>
+	<connection baseUrl="http://cat.dianpingoa.com/cat/r/dashboard">
+		<param type="report" value="problem"></param>
+		<param type="type" value="error"></param>
+	</connection>
+	<duration id="duration1" min="2" max="10" interval="4" alarm-interval="30" alarm="EMAIL"/>
+	<duration id="duration2" min="10" max="40" interval="5" alarm-interval="30" alarm="SMS"/>
+	<duration id="duration3" min="40" max="400" interval="6" alarm-interval="5" alarm="EMAIL,SMS"/>
+</threshold-template>
\ No newline at end of file