提交 c5056f23 编写于 作者: F Frankie Wu

remove unused code

上级 d8c162e6
package com.dianping.cat.consumer;
import com.dianping.cat.consumer.failure.FailureReportAnalyzer;
import com.dianping.cat.consumer.ip.IpAnalyzer;
import com.dianping.cat.consumer.problem.ProblemAnalyzer;
import com.dianping.cat.consumer.transaction.TransactionAnalyzer;
......@@ -15,12 +14,7 @@ public class DefaultAnalyzerFactory extends ContainerHolder implements AnalyzerF
@Override
public MessageAnalyzer create(String name, long start, long duration, String domain, long extraTime) {
if (name.equals("failure")) {
FailureReportAnalyzer analyzer = lookup(FailureReportAnalyzer.class);
analyzer.setAnalyzerInfo(start, duration, domain, extraTime);
return analyzer;
} else if (name.equals("problem")) {
if (name.equals("problem")) {
ProblemAnalyzer analyzer = lookup(ProblemAnalyzer.class);
analyzer.setAnalyzerInfo(start, duration, domain, extraTime);
......
......@@ -10,7 +10,6 @@ import com.dianping.cat.consumer.AnalyzerFactory;
import com.dianping.cat.consumer.DefaultAnalyzerFactory;
import com.dianping.cat.consumer.DefaultMessageQueue;
import com.dianping.cat.consumer.RealtimeConsumer;
import com.dianping.cat.consumer.failure.FailureReportAnalyzer;
import com.dianping.cat.consumer.ip.IpAnalyzer;
import com.dianping.cat.consumer.problem.ProblemAnalyzer;
import com.dianping.cat.consumer.problem.handler.FailureHandler;
......@@ -18,7 +17,6 @@ import com.dianping.cat.consumer.problem.handler.Handler;
import com.dianping.cat.consumer.problem.handler.LongUrlHandler;
import com.dianping.cat.consumer.transaction.TransactionAnalyzer;
import com.dianping.cat.message.spi.MessageConsumer;
import com.dianping.cat.message.spi.MessageManager;
import com.dianping.cat.message.spi.MessagePathBuilder;
import com.dianping.cat.message.spi.MessageQueue;
import com.dianping.cat.storage.BucketManager;
......@@ -56,9 +54,6 @@ public class ComponentsConfigurator extends AbstractResourceConfigurator {
all.add(C(IpAnalyzer.class).is(PER_LOOKUP));
all.add(C(FailureReportAnalyzer.class).is(PER_LOOKUP) //
.req(MessageManager.class));
return all;
}
......
package com.dianping.cat.consumer.failure;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.codehaus.plexus.logging.LogEnabled;
import org.codehaus.plexus.logging.Logger;
import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
import com.dianping.cat.configuration.model.entity.Config;
import com.dianping.cat.configuration.model.entity.Property;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultJsonBuilder;
import com.dianping.cat.message.spi.AbstractMessageAnalyzer;
import com.dianping.cat.message.spi.MessageManager;
import com.dianping.cat.message.spi.MessageStorage;
import com.dianping.cat.message.spi.MessageTree;
import com.site.helper.Files;
import com.site.lookup.annotation.Inject;
/**
* @author sean.wang
* @since Jan 5, 2012
*/
public class FailureAnalyzer extends AbstractMessageAnalyzer<FailureReport> implements Initializable, LogEnabled {
private static final SimpleDateFormat FILE_SDF = new SimpleDateFormat("yyyyMMddHHmm");
private static final long MINUTE = 60 * 1000;
@Inject
private MessageManager m_messageManager;
@Inject
private MessageStorage m_messageStorage;
private Map<String, FailureReport> m_reports = new HashMap<String, FailureReport>();
private long m_extraTime;
private String m_reportPath;
private Logger m_logger;
private long m_startTime;
private long m_duration;
@Override
public void enableLogging(Logger logger) {
m_logger = logger;
}
@Override
protected List<FailureReport> generate() {
List<FailureReport> reports = new ArrayList<FailureReport>(m_reports.size());
for (String domain : m_reports.keySet()) {
FailureReport report = generate(domain);
reports.add(report);
}
return reports;
}
FailureReport generate(String domain) {
if (domain == null) {
List<String> domains = getDomains();
domain = domains.size() > 0 ? domains.get(0) : null;
}
FailureReport report = m_reports.get(domain);
return report;
}
public List<String> getDomains() {
List<String> domains = new ArrayList<String>(m_reports.keySet());
Collections.sort(domains, new Comparator<String>() {
@Override
public int compare(String d1, String d2) {
if (d1.equals("Cat")) {
return 1;
}
return d1.compareTo(d2);
}
});
return domains;
}
public FailureReport getReport(String domain) {
return m_reports.get(domain);
}
public Map<String, FailureReport> getReports() {
return m_reports;
}
private String getFailureFileName(FailureReport report) {
StringBuffer result = new StringBuffer();
String start = FILE_SDF.format(report.getStartTime());
String end = FILE_SDF.format(report.getEndTime());
result.append(report.getDomain()).append("-").append(start).append("-").append(end);
return result.toString();
}
@Override
public void initialize() throws InitializationException {
Config config = m_messageManager.getClientConfig();
if (config != null) {
Property property = config.findProperty("failure-base-dir");
if (property != null) {
m_reportPath = property.getValue();
}
}
}
@Override
protected boolean isTimeout() {
long currentTime = System.currentTimeMillis();
long endTime = m_startTime + m_duration + m_extraTime;
return currentTime > endTime;
}
@Override
protected void process(MessageTree tree) {
String domain = tree.getDomain();
FailureReport report = m_reports.get(domain);
if (report == null) {
report = new FailureReport();
report.setDomain(domain);
report.setStartTime(new Date(m_startTime));
report.setEndTime(new Date(m_startTime + MINUTE * 60 - 1));
m_reports.put(domain, report);
}
// TODO
}
public void setAnalyzerInfo(long startTime, long duration, String domain, long extraTime) {
m_extraTime = extraTime;
m_startTime = startTime;
m_duration = duration;
}
public void setMessageStorage(MessageStorage messageStorage) {
m_messageStorage = messageStorage;
}
public void setReportPath(String reportPath) {
m_reportPath = reportPath;
}
@Override
protected void store(List<FailureReport> reports) {
if (reports == null || reports.size() == 0) {
return;
}
for (FailureReport report : reports) {
String failureFileName = getFailureFileName(report);
String htmlPath = new StringBuilder().append(m_reportPath).append(failureFileName).append(".html").toString();
File file = new File(htmlPath);
file.getParentFile().mkdirs();
try {
Files.forIO().writeTo(file, new DefaultJsonBuilder().buildJson(report));
} catch (IOException e) {
m_logger.error(String.format("Error when writing to file(%s)!", file), e);
}
}
}
}
package com.dianping.cat.consumer.failure;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
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.configuration.model.entity.Config;
import com.dianping.cat.configuration.model.entity.Property;
import com.dianping.cat.consumer.failure.model.entity.Entry;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.entity.Segment;
import com.dianping.cat.consumer.failure.model.entity.Threads;
import com.dianping.cat.message.Event;
import com.dianping.cat.message.Message;
import com.dianping.cat.message.Transaction;
import com.dianping.cat.message.spi.AbstractMessageAnalyzer;
import com.dianping.cat.message.spi.MessageManager;
import com.dianping.cat.message.spi.MessageStorage;
import com.dianping.cat.message.spi.MessageTree;
import com.site.helper.Splitters;
import com.site.lookup.annotation.Inject;
/**
* @author yong.you
* @since Jan 5, 2012
*/
public class FailureReportAnalyzer extends AbstractMessageAnalyzer<FailureReport> implements Initializable {
@Inject
private List<Handler> m_handlers;
@Inject
private String m_reportPath;
@Inject
private MessageManager m_manager;
// Key: the domain:host of the message. Sample: Review:192.168.1.1
private Map<String, FailureReport> m_reports = new HashMap<String, FailureReport>();
private long m_startTime;
private long m_extraTime;
private long m_duration;
private static final long MINUTE = 60 * 1000;
private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm");
private static final SimpleDateFormat FILE_SDF = new SimpleDateFormat("yyyyMMddHHmm");
public void addHandlers(Handler handler) {
if (m_handlers == null) {
m_handlers = new ArrayList<FailureReportAnalyzer.Handler>();
}
m_handlers.add(handler);
}
@Override
public List<FailureReport> generate() {
List<FailureReport> reports = new ArrayList<FailureReport>();
for (String domainAndIp : m_reports.keySet()) {
String[] temp = domainAndIp.split(":");
reports.add(generateByDomainAndIp(temp[0], temp[1]));
}
return reports;
}
public FailureReport generateByDomainAndIp(String domain, String ip) {
FailureReport m_report = getReportByDomainAndIp(domain, ip);
long time = System.currentTimeMillis();
long endTime = time - time % (60 * 1000);
long start = m_report.getStartTime().getTime();
long reportEndTime = m_report.getEndTime().getTime();
if (reportEndTime < endTime)
endTime = reportEndTime;
Map<String, Segment> oldSegments = m_report.getSegments();
Map<String, Segment> newSegments = new LinkedHashMap<String, Segment>();
for (; start <= endTime; start = start + 60 * 1000) {
String minute = SDF.format(new Date(start));
Segment segment = oldSegments.get(minute);
if (segment != null) {
newSegments.put(minute, segment);
} else {
newSegments.put(minute, new Segment(minute));
}
}
oldSegments.clear();
for (java.util.Map.Entry<String, Segment> entry : newSegments.entrySet()) {
oldSegments.put(entry.getKey(), newSegments.get(entry.getValue()));
}
return m_report;
}
public List<String> getAllDomains() {
Set<String> domainAndIps = m_reports.keySet();
Set<String> result = new HashSet<String>();
if (domainAndIps != null) {
for (String domainAndIp : domainAndIps) {
result.add(domainAndIp.substring(0, domainAndIp.lastIndexOf(":")));
}
}
ArrayList<String> domains = new ArrayList<String>(result);
Collections.sort(domains, new Comparator<String>() {
@Override
public int compare(String d1, String d2) {
if (d1.equals("Cat")) {
return 1;
}
return d1.compareTo(d2);
}
});
return domains;
}
public String getFailureFilePath(FailureReport report) {
StringBuffer result = new StringBuffer();
String start = FILE_SDF.format(report.getStartTime());
String end = FILE_SDF.format(report.getEndTime());
result.append(m_reportPath).append(report.getDomain()).append(report.getMachine()).append("-").append(start)
.append("-").append(end).append(".html");
return result.toString();
}
public List<String> getHostIpByDomain(String domain) {
Set<String> domainAndIps = m_reports.keySet();
Set<String> result = new HashSet<String>();
if (domainAndIps != null) {
for (String domainAndIp : domainAndIps) {
int index = domainAndIp.lastIndexOf(":");
if (domainAndIp.substring(0, index).equals(domain)) {
String ip = domainAndIp.substring(index + 1);
result.add(ip);
}
}
}
return new ArrayList<String>(result);
}
private FailureReport getReportByDomainAndIp(String domain, String ip) {
String domainAndIp = new StringBuffer().append(domain).append(":").append(ip).toString();
FailureReport report = m_reports.get(domainAndIp);
if (report != null) {
return report;
}
FailureReport addedReport = new FailureReport();
addedReport.setStartTime(new Date(m_startTime));
addedReport.setEndTime(new Date(m_startTime + m_duration - MINUTE));
addedReport.setDomain(domain);
addedReport.setThreads(new Threads());
m_reports.put(domainAndIp, addedReport);
return addedReport;
}
public String getReportPath() {
return m_reportPath;
}
public Map<String, FailureReport> getReports() {
return m_reports;
}
@Override
public void initialize() throws InitializationException {
Config config = m_manager.getClientConfig();
if (config != null) {
Property property = config.findProperty("failure-base-dir");
if (property != null) {
m_reportPath = property.getValue();
}
}
}
@Override
protected boolean isTimeout() {
long endTime = m_startTime + m_duration + m_extraTime;
long currentTime = System.currentTimeMillis();
if (currentTime > endTime + m_extraTime) {
return true;
}
return false;
}
@Override
protected void process(MessageTree tree) {
if (m_handlers == null) {
throw new RuntimeException();
}
String domain = tree.getDomain();
String ip = tree.getIpAddress();
FailureReport report = getReportByDomainAndIp(domain, ip);
report.getThreads().addThread(tree.getThreadId());
if (null == report.getMachine()) {
report.setMachine(tree.getIpAddress());
}
for (Handler handler : m_handlers) {
handler.handle(report, tree);
}
}
public void setAnalyzerInfo(long startTime, long duration, String domain, long extraTime) {
m_extraTime = extraTime;
m_startTime = startTime;
m_duration = duration;
}
public void setReportPath(String configPath) {
m_reportPath = configPath;
}
public void setReports(Map<String, FailureReport> reports) {
m_reports = reports;
}
@Override
protected void store(List<FailureReport> reports) {
if (reports != null) {
for (FailureReport report : reports) {
File file = new File(getFailureFilePath(report));
file.getParentFile().mkdirs();
FailureReportStore.storeToHtml(file, report);
}
}
}
public static abstract class AbstractHandler implements Handler {
@Inject
private MessageStorage m_storage;
protected Segment findOrCreateSegment(Message message, FailureReport report) {
long time = message.getTimestamp();
long segmentId = time - time % MINUTE;
String segmentStr = getDateFormat(segmentId);
Map<String, Segment> segments = report.getSegments();
Segment segment = segments.get(segmentStr);
if (segment == null) {
segment = new Segment(segmentStr);
segments.put(segmentStr, segment);
}
return segment;
}
private String getDateFormat(long time) {
String result = "2012-01-01 00:00";
try {
Date date = new Date(time);
result = SDF.format(date);
} catch (Exception e) {
}
return result;
}
private Entry getEntry(MessageTree tree) {
String url = m_storage.store(tree);
Entry entry = new Entry();
entry.setPath(url);
entry.setThreadId(tree.getThreadId());
return entry;
}
public void setMessageStorage(MessageStorage storage) {
m_storage = storage;
}
}
public static class FailureHandler extends AbstractHandler {
@Inject
private Set<String> m_failureTypes;
private void addEntry(FailureReport report, Message message, MessageTree tree) {
Entry entry = super.getEntry(tree);
entry.setText(message.getName());
entry.setType(message.getType());
Segment segment = super.findOrCreateSegment(message, report);
segment.addEntry(entry);
}
@Override
public void handle(FailureReport report, MessageTree tree) {
Message message = tree.getMessage();
if (message instanceof Transaction) {
Transaction transaction = (Transaction) message;
processTransaction(report, transaction, tree);
} else if (message instanceof Event) {
processEvent(report, message, tree);
}
}
private void processEvent(FailureReport report, Message message, MessageTree tree) {
if (m_failureTypes.contains(message.getType())) {
addEntry(report, message, tree);
}
}
private void processTransaction(FailureReport report, Transaction transaction, MessageTree tree) {
if (m_failureTypes.contains(transaction.getType())) {
addEntry(report, transaction, tree);
}
List<Message> messageList = transaction.getChildren();
for (Message message : messageList) {
if (message instanceof Transaction) {
Transaction temp = (Transaction) message;
processTransaction(report, temp, tree);
} else if (message instanceof Event) {
processEvent(report, message, tree);
}
}
}
public void setFailureType(String type) {
m_failureTypes = new HashSet<String>(Splitters.by(',').noEmptyItem().split(type));
}
}
public static interface Handler {
public void handle(FailureReport report, MessageTree tree);
}
public static class LongUrlHandler extends AbstractHandler {
@Inject
private long m_threshold;
private static final String LONG_URL = "LongUrl";
@Override
public void handle(FailureReport report, MessageTree tree) {
Message message = tree.getMessage();
if (message instanceof Transaction) {
Transaction t = (Transaction) message;
if (t.getDuration() > m_threshold) {
Entry entry = super.getEntry(tree);
entry.setText(message.getType() + "." + message.getName());
entry.setType(LONG_URL);
Segment segment = super.findOrCreateSegment(message, report);
segment.addEntry(entry);
}
}
}
public void setThreshold(long threshold) {
m_threshold = threshold;
}
}
}
package com.dianping.cat.consumer.failure;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultJsonBuilder;
import com.site.helper.Files;
public class FailureReportStore {
private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm");
private static final String END = "\n";
public static void storeToHtml(File file, FailureReport report) {
try {
Files.forIO().writeTo(file, getStoreString(report));
} catch (IOException e) {
throw new RuntimeException(String.format("Unable to create file %s!", file), e);
}
}
public static String getStoreString(FailureReport report) {
StringBuilder result = new StringBuilder();
String jsonString = new DefaultJsonBuilder().buildJson(report);
result.append("<html>").append(END).append("<head>").append(END).append("<title>").append(END).append(
"Failure Report ").append("From ").append(SDF.format(report.getStartTime())).append(" To ").append(
SDF.format(report.getEndTime())).append(END).append("</title>").append(END).append("<body>").append(END)
.append(jsonString).append("</body>").append(END).append("</html>").append(END);
return result.toString();
}
}
......@@ -184,7 +184,11 @@ public class ProblemAnalyzer extends AbstractMessageAnalyzer<ProblemReport> impl
String sessionTag = "s:" + tree.getSessionToken();
String requestTag = "r:" + messageId;
m_messageBucket.storeById(messageId, tree, threadTag, sessionTag, requestTag);
try {
m_messageBucket.storeById(messageId, tree, threadTag, sessionTag, requestTag);
} catch (IOException e) {
m_logger.error("Error when storing message for problem analyzer!", e);
}
}
}
......
......@@ -184,7 +184,7 @@ public class TransactionAnalyzer extends AbstractMessageAnalyzer<TransactionRepo
try {
m_messageBucket.storeById(messageId, tree, threadTag, sessionTag, requestTag);
} catch (IOException e) {
m_logger.error("", e);
m_logger.error("Error when storing message for transaction analyzer!", e);
}
}
}
......
package com.dianping.cat.tools;
public class DateUtil {
}
package com.dianping.cat.tools;
public class SystemUtil {
private static boolean IS_WINDOWS;
static {
String osName = System.getProperty("os.name");
if (osName != null && osName.toLowerCase().indexOf("windows") > -1) {
IS_WINDOWS = true;
}
}
public static boolean isWindows(){
return IS_WINDOWS;
}
}
......@@ -79,15 +79,5 @@
<implementation>com.dianping.cat.consumer.ip.IpAnalyzer</implementation>
<instantiation-strategy>per-lookup</instantiation-strategy>
</component>
<component>
<role>com.dianping.cat.consumer.failure.FailureReportAnalyzer</role>
<implementation>com.dianping.cat.consumer.failure.FailureReportAnalyzer</implementation>
<instantiation-strategy>per-lookup</instantiation-strategy>
<requirements>
<requirement>
<role>com.dianping.cat.message.spi.MessageManager</role>
</requirement>
</requirements>
</component>
</components>
</plexus>
......@@ -4,9 +4,6 @@ import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import com.dianping.cat.consumer.failure.FailureAnalyzerStoreTest;
import com.dianping.cat.consumer.failure.FailureAnalyzerTest;
import com.dianping.cat.consumer.failure.FailureReportTest;
import com.dianping.cat.consumer.ip.IpReportTest;
import com.dianping.cat.consumer.transaction.NumberFormatTest;
import com.dianping.cat.consumer.transaction.TransactionReportMessageAnalyzerTest;
......@@ -19,13 +16,6 @@ ManyAnalyzerTest.class,
OneAnalyzerTwoDurationTest.class,
/* .failure */
FailureAnalyzerTest.class,
FailureAnalyzerStoreTest.class,
FailureReportTest.class,
/* .ip */
IpReportTest.class,
......
package com.dianping.cat.consumer.failure;
import java.io.File;
import java.util.List;
import junit.framework.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import com.dianping.cat.consumer.AnalyzerFactory;
import com.dianping.cat.consumer.failure.FailureReportAnalyzer.Handler;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultJsonBuilder;
import com.dianping.cat.message.internal.DefaultTransaction;
import com.dianping.cat.message.spi.MessageTree;
import com.dianping.cat.message.spi.internal.DefaultMessageTree;
import com.site.helper.Files;
import com.site.lookup.ComponentTestCase;
@RunWith(JUnit4.class)
public class FailureAnalyzerStoreTest extends ComponentTestCase {
private String m_domain="middleware";
private String m_host="127.0.0.1";
@Test
public void testLookup() throws Exception {
Handler failure = lookup(Handler.class, "failure-handler");
Handler longUrl = lookup(Handler.class, "long-url-handler");
// make sure all handlers could be looked up successfully
Assert.assertNotNull(failure);
Assert.assertNotNull(longUrl);
}
@Test
public void testJson() throws Exception {
long current = 1327470645035L;
long duration = 60 * 60 * 1000;
long extraTime = 5 * 60 * 1000;
long start = current - current % (60 * 60 * 1000);
AnalyzerFactory factory = lookup(AnalyzerFactory.class);
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) factory.create("failure", start, duration, m_domain,
extraTime);
int number = 5;
for (int i = 0; i < number; i++) {
DefaultTransaction t = new DefaultTransaction("A1", "B1", null);
MessageTree tree = new DefaultMessageTree();
tree.setMessageId("MessageId" + i);
tree.setThreadId("Thread" + i);
tree.setDomain(m_domain);
tree.setHostName(m_host);
tree.setIpAddress(m_host);
tree.setMessage(t);
t.setDuration(3 * 1000);
t.setTimestamp(start + 1000L * 60 * i);
analyzer.process(tree);
analyzer.process(tree);
analyzer.process(tree);
}
List<FailureReport> report = analyzer.generate();
analyzer.store(report);
FailureReport targetReport = analyzer.generateByDomainAndIp(m_domain,m_host);
String json = new DefaultJsonBuilder().buildJson(targetReport);
String expected = Files.forIO().readFrom(getResourceFile("failure.json"), "utf-8");
Assert.assertEquals("Check json content!", expected.replace("\r", ""), json.replace("\r", ""));
}
@Test
public void testStore() throws Exception {
long current = System.currentTimeMillis();
long duration = 60 * 60 * 1000;
long extraTime = 5 * 60 * 1000;
long start = current - current % (60 * 60 * 1000);
AnalyzerFactory factory = lookup(AnalyzerFactory.class);
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) factory.create("failure", start, duration, m_domain,
extraTime);
int number = 20;
for (int i = 0; i < number; i++) {
DefaultTransaction t = new DefaultTransaction("A1", "B1", null);
MessageTree tree = new DefaultMessageTree();
tree.setMessageId("thread0001");
tree.setDomain(m_domain);
tree.setHostName("middleware");
tree.setIpAddress(m_host);
tree.setThreadId("Thread" + i%5);
tree.setMessage(t);
t.setDuration(3 * 1000);
t.setTimestamp(start + 1000L * 60 * i);
analyzer.process(tree);
}
List<FailureReport> report = analyzer.generate();
analyzer.store(report);
FailureReport targetReport = analyzer.generateByDomainAndIp(m_domain,m_host);
String pathname = analyzer.getFailureFilePath(targetReport);
File storeFile = new File(pathname);
Assert.assertEquals("Check file is exist!", true, storeFile.exists());
String realResult = Files.forIO().readFrom(storeFile, "utf-8");
String exceptedResult = FailureReportStore.getStoreString(targetReport);
Assert.assertEquals("Check file content!", exceptedResult, realResult);
}
}
package com.dianping.cat.consumer.failure;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import com.dianping.cat.consumer.AnalyzerFactory;
import com.dianping.cat.consumer.failure.model.entity.Entry;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.entity.Segment;
import com.dianping.cat.message.Message;
import com.dianping.cat.message.internal.DefaultEvent;
import com.dianping.cat.message.internal.DefaultTransaction;
import com.dianping.cat.message.spi.MessageTree;
import com.dianping.cat.message.spi.internal.DefaultMessageTree;
import com.site.lookup.ComponentTestCase;
@RunWith(JUnit4.class)
public class FailureAnalyzerTest extends ComponentTestCase {
private String m_domain = "domain1";
private String m_host = "127.0.0.1";
private static final long HOUR = 1000L * 60 * 60;
@Test
public void testFailureHandler() throws Exception {
long current = System.currentTimeMillis();
long duration = 60 * 60 * 1000;
long extraTime = 5 * 60 * 1000;
long start = current - current % (60 * 60 * 1000) - HOUR;
AnalyzerFactory factory = lookup(AnalyzerFactory.class);
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) factory.create("failure", start, duration, m_domain,
extraTime);
// Just for one hour
int number = 60 * 10;
int threadNumber = 10;
DefaultEvent e11 = new DefaultEvent("Error", "testError");
DefaultEvent e21 = new DefaultEvent("Exception", "testException1");
DefaultEvent e31 = new DefaultEvent("RuntimeException", "testRuntimeException1");
DefaultEvent e22 = new DefaultEvent("Exception", "testException2");
DefaultEvent e32 = new DefaultEvent("RuntimeException", "testRuntimeException2");
MessageTree tree = new DefaultMessageTree();
tree.setMessageId("xx0001");
tree.setDomain(m_domain);
tree.setHostName(m_host);
tree.setIpAddress(m_host);
DefaultTransaction t1 = new DefaultTransaction("T1", "N1", null);
DefaultTransaction t2 = new DefaultTransaction("T2", "N2", null);
DefaultTransaction t3 = new DefaultTransaction("T3", "N3", null);
t2.addChild(t3);
t2.addChild(e21);
t2.addChild(e22);
t3.addChild(e31);
t3.addChild(e32);
t2.setStatus("ERROR");
t2.complete();
t1.setStatus(Message.SUCCESS);
t1.complete();
t1.addChild(t2);
t1.addChild(e11);
tree.setMessage(t1);
long ct = System.nanoTime();
for (int i = 0; i < number; i++) {
if (i == 1) {
ct = System.nanoTime();
}
long addTime = 6 * 1000 * i;
long timestamp = start + addTime;
t1.setTimestamp(timestamp);
t2.setTimestamp(timestamp);
t3.setTimestamp(timestamp);
e11.setTimestamp(timestamp);
e21.setTimestamp(timestamp);
e22.setTimestamp(timestamp);
e31.setTimestamp(timestamp);
e32.setTimestamp(timestamp);
tree.setThreadId("thread" + i % threadNumber);
analyzer.process(tree);
}
long time = System.nanoTime() - ct;
System.out.println("time: " + time / 1e6 + " ms," + (time / 1e6 / number) + " ms each");
FailureReport report = analyzer.generateByDomainAndIp(m_domain, m_host);
assertEquals("Check the domain", report.getDomain(), "domain1");
assertEquals("Check the machines", m_host, report.getMachine());
assertEquals("Check the threads", threadNumber, report.getThreads().getThreads().size());
Date startDate = report.getStartTime();
Date endDate = report.getEndTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String startStr = sdf.format(startDate);
String endStr = sdf.format(endDate);
Date realStartDate = new Date(start);
Date realEndDate = new Date(start + duration - 60 * 1000);
assertEquals("Check the report start time", sdf.format(realStartDate), startStr);
assertEquals("Check the report end time", sdf.format(realEndDate), endStr);
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
Map<String, Segment> segments = report.getSegments();
for (int i = 0; i < number / 10; i++) {
String minuteStr = sdf2.format(startDate);
Segment temp = segments.get(minuteStr);
List<Entry> entries = temp.getEntries();
if (entries == null) {
System.out.println(minuteStr);
} else {
assertEquals("Check the segment size ", 50, entries.size());
}
startDate.setTime(startDate.getTime() + 1000 * 60);
}
}
@Test
public void testLongUrlHander() throws Exception {
long current = System.currentTimeMillis();
long duration = 60 * 60 * 1000;
long extraTime = 5 * 60 * 1000;
long start = current - current % (60 * 60 * 1000) - HOUR;
String domain = "domain1";
AnalyzerFactory factory = lookup(AnalyzerFactory.class);
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) factory.create("failure", start, duration, domain,
extraTime);
int number = 60;
for (int i = 0; i < number; i++) {
DefaultTransaction t = new DefaultTransaction("A1", "B1", null);
MessageTree tree = new DefaultMessageTree();
tree.setMessageId("thread0001");
tree.setDomain(m_domain);
tree.setHostName("middleware");
tree.setIpAddress(m_host);
tree.setMessage(t);
t.setDuration(3 * 1000);
t.setTimestamp(start + 1000L * 60 * i);
analyzer.process(tree);
// analyzer.process(tree);
}
FailureReport report = analyzer.generateByDomainAndIp(domain, m_host);
assertEquals("Check the machines", m_host, report.getMachine());
assertEquals("Check the domain", report.getDomain(), "domain1");
Date startDate = report.getStartTime();
Date endDate = report.getEndTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String startStr = sdf.format(startDate);
String endStr = sdf.format(endDate);
Date realStartDate = new Date(start);
Date realEndDate = new Date(start + duration - 60 * 1000);
assertEquals("Check the report start time", sdf.format(realStartDate), startStr);
assertEquals("Check the report end time", sdf.format(realEndDate), endStr);
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
Map<String, Segment> segments = report.getSegments();
for (int i = 0; i < 60; i++) {
String minuteStr = sdf2.format(startDate);
Segment temp = segments.get(minuteStr);
assertEquals("Check the segment size ", temp.getEntries().size(), 1);
startDate.setTime(startDate.getTime() + 1000 * 60);
}
}
@Test
public void testManyDomainAndIp() throws Exception {
long current = System.currentTimeMillis();
long duration = 60 * 60 * 1000;
long extraTime = 5 * 60 * 1000;
long start = current - current % (60 * 60 * 1000) - HOUR;
String baseDaomain = "domain";
String baseIp = "192.168.1.";
AnalyzerFactory factory = lookup(AnalyzerFactory.class);
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) factory
.create("failure", start, duration, "", extraTime);
int number = 60;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int index = 0; index < number; index++) {
DefaultTransaction t = new DefaultTransaction("A1", "B1", null);
MessageTree tree = new DefaultMessageTree();
tree.setMessageId("thread0001");
tree.setDomain(baseDaomain + i);
tree.setIpAddress(baseIp + j);
tree.setMessage(t);
t.setDuration(3 * 1000);
t.setTimestamp(start + 1000L * 60 * index);
analyzer.process(tree);
}
}
}
Map<String, FailureReport> reports = analyzer.getReports();
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
FailureReport report = reports.get(baseDaomain + i + ":" + baseIp + j);
assertEquals("Check the report is not null", report == null, false);
assertEquals("Check the machine", baseIp + j, report.getMachine());
assertEquals("Check the domain", baseDaomain + i, report.getDomain());
Date startDate = report.getStartTime();
Date endDate = report.getEndTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String startStr = sdf.format(startDate);
String endStr = sdf.format(endDate);
Date realStartDate = new Date(start);
Date realEndDate = new Date(start + duration - 60 * 1000);
assertEquals("Check the report start time", sdf.format(realStartDate), startStr);
assertEquals("Check the report end time", sdf.format(realEndDate), endStr);
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
Map<String, Segment> segments = report.getSegments();
for (int k = 0; k < 60; k++) {
String minuteStr = sdf2.format(startDate);
Segment temp = segments.get(minuteStr);
assertEquals("Check the segment size ",temp.getEntries().size(), 1);
startDate.setTime(startDate.getTime() + 1000 * 60);
}
}
}
}
}
package com.dianping.cat.consumer.failure;
import org.junit.Assert;
import org.junit.Test;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultJsonBuilder;
import com.dianping.cat.consumer.failure.model.transform.DefaultXmlBuilder;
import com.dianping.cat.consumer.failure.model.transform.DefaultXmlParser;
import com.site.helper.Files;
public class FailureReportTest {
@Test
public void testXml() throws Exception {
DefaultXmlParser parser = new DefaultXmlParser();
String source = Files.forIO().readFrom(getClass().getResourceAsStream("FailureReport.xml"), "utf-8");
FailureReport report = parser.parse(source);
String xml = new DefaultXmlBuilder().buildXml(report);
String expected = source;
Assert.assertEquals("XML is not well parsed!", expected.replace("\r", ""), xml.replace("\r", ""));
}
@Test
public void testJson() throws Exception {
DefaultXmlParser parser = new DefaultXmlParser();
String source = Files.forIO().readFrom(getClass().getResourceAsStream("FailureReport.xml"), "utf-8");
FailureReport report = parser.parse(source);
String json = new DefaultJsonBuilder().buildJson(report);
String expected = Files.forIO().readFrom(getClass().getResourceAsStream("FailureReport.json"), "utf-8");
Assert.assertEquals("XML is not well parsed or JSON is not well built!", expected.replace("\r", ""),
json.replace("\r", ""));
}
}
......@@ -18,18 +18,20 @@
<groupId>org.jboss.netty</groupId>
<artifactId>netty</artifactId>
</dependency>
<dependency>
<groupId>com.site.common</groupId>
<artifactId>test-framework</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.site.common</groupId>
<artifactId>test-framework</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
......
package com.dianping.cat.log;
package com.dianping.cat.log4j;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;
......@@ -8,12 +8,11 @@ import org.apache.log4j.spi.ThrowableInformation;
import com.dianping.cat.Cat;
public class CatAppender extends AppenderSkeleton {
@Override
protected void append(LoggingEvent event) {
if (event.getLevel().isGreaterOrEqual(Level.ERROR)) {
ThrowableInformation throwableInformation = event.getThrowableInformation();
if (throwableInformation != null) {
if (Cat.getManager().getThreadLocalMessageTree() != null) {
Cat.getProducer().logError(throwableInformation.getThrowable());
......@@ -25,13 +24,13 @@ public class CatAppender extends AppenderSkeleton {
}
}
}
@Override
public void close() {
}
@Override
public boolean requiresLayout() {
return true;
return false;
}
}
<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
<xs:element name="config" type="ConfigType"/>
<xs:complexType name="ConfigType">
<xs:sequence>
<xs:element name="app" type="AppType" minOccurs="0" maxOccurs="1"/>
<xs:element name="servers">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:element name="server" type="ServerType"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="bind" type="BindType" minOccurs="0" maxOccurs="1"/>
<xs:element name="filter" type="FilterType" minOccurs="0" maxOccurs="1"/>
<xs:element name="properties">
<xs:complexType>
<xs:sequence minOccurs="0" maxOccurs="unbounded">
<xs:element name="property" type="PropertyType"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="mode" type="xs:string" use="required"/>
<xs:attribute name="base-log-dir" type="xs:string" default="target/catlog"/>
<xs:attribute name="base-log-url" type="xs:string"/>
</xs:complexType>
<xs:complexType name="AppType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="domain" type="xs:string" use="required"/>
<xs:attribute name="ip" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="ServerType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="ip" type="xs:string"/>
<xs:attribute name="port" type="xs:int" default="2280"/>
<xs:attribute name="enabled" type="xs:boolean" default="true"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="BindType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="ip" type="xs:string"/>
<xs:attribute name="port" type="xs:int" default="2280"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:complexType name="FilterType">
<xs:sequence>
<xs:element name="domain" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="PropertyType">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="name" type="xs:string" use="required"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
<?xml version="1.0" encoding="utf-8"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="config.xsd" mode="">
<app domain=""/>
<servers>
<server/>
<!-- more server -->
</servers>
<bind/>
<filter>
<domain>{domain}</domain>
<!-- more domain -->
</filter>
<properties>
<property name=""/>
<!-- more property -->
</properties>
</config>
......@@ -11,14 +11,10 @@ com.dianping.cat.report.page.home.Handler.class,
com.dianping.cat.report.page.transaction.Handler.class,
com.dianping.cat.report.page.failure.Handler.class,
com.dianping.cat.report.page.logview.Handler.class,
com.dianping.cat.report.page.ip.Handler.class,
com.dianping.cat.report.page.service.Handler.class,
com.dianping.cat.report.page.model.Handler.class,
com.dianping.cat.report.page.problem.Handler.class
......
......@@ -11,13 +11,7 @@ import com.dianping.cat.report.graph.DefaultGraphBuilder;
import com.dianping.cat.report.graph.DefaultValueTranslater;
import com.dianping.cat.report.graph.GraphBuilder;
import com.dianping.cat.report.graph.ValueTranslater;
import com.dianping.cat.report.page.failure.FailureManager;
import com.dianping.cat.report.page.ip.IpManager;
import com.dianping.cat.report.page.service.provider.FailureModelProvider;
import com.dianping.cat.report.page.service.provider.IpModelProvider;
import com.dianping.cat.report.page.service.provider.ModelProvider;
import com.dianping.cat.report.page.service.provider.TransactionModelProvider;
import com.dianping.cat.report.page.transaction.TransactionManager;
import com.site.lookup.configuration.AbstractResourceConfigurator;
import com.site.lookup.configuration.Component;
......@@ -38,17 +32,6 @@ public class ComponentsConfigurator extends AbstractResourceConfigurator {
.config(E("consumerServers").value("127.0.0.1:2281"))//
.config(E("fileServer").value("127.0.0.1")));
all.add(C(ModelProvider.class, "failure", FailureModelProvider.class).req(MessageConsumer.class, "realtime"));
all.add(C(ModelProvider.class, "transaction", TransactionModelProvider.class).req(MessageConsumer.class,
"realtime"));
all.add(C(ModelProvider.class, "ip", IpModelProvider.class).req(MessageConsumer.class, "realtime"));
all.add(C(FailureManager.class));
all.add(C(TransactionManager.class));
all.add(C(IpManager.class));
all.add(C(ValueTranslater.class, DefaultValueTranslater.class));
......
package com.dianping.cat.report.page.failure;
public enum Action implements com.site.web.mvc.Action {
VIEW("view");
private String m_name;
private Action(String name) {
m_name = name;
}
public static Action getByName(String name, Action defaultAction) {
for (Action action : Action.values()) {
if (action.getName().equals(name)) {
return action;
}
}
return defaultAction;
}
@Override
public String getName() {
return m_name;
}
}
package com.dianping.cat.report.page.failure;
import com.dianping.cat.report.ReportContext;
public class Context extends ReportContext<Payload> {
}
package com.dianping.cat.report.page.failure;
import java.util.Date;
import com.dianping.cat.report.ReportManager;
import com.dianping.cat.report.tool.DateUtils;
public class FailureManager extends ReportManager{
public String getConnectionUrl(String server,String domain, String ip, String duration){
StringBuffer result = new StringBuffer("http://").append(server).append("/cat/r/service?model=failure");
if (domain != null && domain.length() > 0) {
result.append("&").append("domain=").append(domain);
}
if (duration != null && duration.length() > 0) {
result.append("&").append("index=").append(duration);
}
if (ip != null && ip.length() > 0) {
result.append("&").append("ip=").append(ip);
}
return result.toString();
}
public String getReportStoreFile (long startHour, String domain, String ip){
long hour = DateUtils.HOUR;
long second = DateUtils.SECOND;
StringBuilder result = new StringBuilder();
result.append(domain).append(ip).append("-").append(DateUtils.SDF_URL.format(new Date(startHour))).append("-")
.append(DateUtils.SDF_URL.format(new Date(startHour + hour - second * 60))).append(".html");
return result.toString();
}
public String getReportDisplayTitle (String domain, String ip, long startHour){
long currentTimeMillis = System.currentTimeMillis();
long end = startHour + DateUtils.HOUR - DateUtils.SECOND;
if (end > currentTimeMillis) {
end = currentTimeMillis;
}
StringBuilder title = new StringBuilder().append("Domain:").append(domain).append(" IP ").append(ip);
title.append(" From ").append(DateUtils.SDF_SEG.format(new Date(startHour))).append(" To ").append(
DateUtils.SDF_SEG.format(new Date(end)));
return title.toString();
}
public String getBaseUrl(String currentDomain, String currentIp, String reportCurrentTime) {
StringBuffer urlPrefix = new StringBuffer("?domain=");
urlPrefix.append(currentDomain).append("&current=").append(reportCurrentTime).append("&ip=").append(currentIp)
.append("&method=");
return urlPrefix.toString();
}
}
package com.dianping.cat.report.page.failure;
import com.dianping.cat.consumer.failure.model.entity.Entry;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.entity.Threads;
import com.dianping.cat.consumer.failure.model.transform.DefaultMerger;
public class FailureReportMerger extends DefaultMerger {
public FailureReportMerger(FailureReport failureReport) {
super(failureReport);
}
@Override
protected void mergeEntry(Entry old, Entry entry) {
// TODO Auto-generated method stub
super.mergeEntry(old, entry);
}
@Override
protected void mergeThreads(Threads old, Threads threads) {
old.getThreads().addAll(threads.getThreads());
}
}
package com.dianping.cat.report.page.failure;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.servlet.ServletException;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultJsonBuilder;
import com.dianping.cat.report.ReportPage;
import com.dianping.cat.report.ServerConfig;
import com.dianping.cat.report.tool.Constants;
import com.dianping.cat.report.tool.DateUtils;
import com.dianping.cat.report.tool.ReportUtils;
import com.dianping.cat.report.tool.StringUtils;
import com.site.lookup.annotation.Inject;
import com.site.web.mvc.PageHandler;
import com.site.web.mvc.annotation.InboundActionMeta;
import com.site.web.mvc.annotation.OutboundActionMeta;
import com.site.web.mvc.annotation.PayloadMeta;
public class Handler implements PageHandler<Context> {
@Inject
private ServerConfig serverConfig;
@Inject
private JspViewer m_jspViewer;
@Inject
private FailureManager m_manager;
@Override
@PayloadMeta(Payload.class)
@InboundActionMeta(name = "f")
public void handleInbound(Context ctx) throws ServletException, IOException {
// display only, no action here
}
@Override
@OutboundActionMeta(name = "f")
public void handleOutbound(Context ctx) throws ServletException, IOException {
Model model = new Model(ctx);
Payload payload = ctx.getPayload();
model.setAction(Action.VIEW);
model.setPage(ReportPage.FAILURE);
long currentTimeMillis = System.currentTimeMillis();
long currentHour = currentTimeMillis - currentTimeMillis % DateUtils.HOUR;
String currentDomain = payload.getDomain();
String currentIp = payload.getIp();
String urlCurrent = payload.getCurrent();
int method = payload.getMethod();
long reportStart = m_manager.computeReportStartHour(currentHour, urlCurrent, method);
String reportCurrentTime = DateUtils.SDF_URL.format(new Date(reportStart));
String index = m_manager.getReportStartType(currentHour, reportStart);
model.setCurrent(reportCurrentTime);
if (index.equals(Constants.MEMORY_CURRENT) || index.equals(Constants.MEMORY_LAST)) {
List<FailureReport> reports = new ArrayList<FailureReport>();
List<String> servers = serverConfig.getConsumerServers();
Set<String> domains = new HashSet<String>();
Set<String> ips = new HashSet<String>();
for (String server : servers) {
String connectionUrl = m_manager.getConnectionUrl(server, currentDomain, currentIp, index);
String pageResult = m_manager.getRemotePageContent(connectionUrl);
if(pageResult!=null){
List<String> domainTemps = StringUtils.getListFromPage(pageResult, "<domains>", "</domains>");
if (domainTemps != null) {
for (String temp : domainTemps) {
domains.add(temp);
}
}
List<String> ipsTemps = StringUtils.getListFromPage(pageResult, "<ips>", "</ips>");
if (domainTemps != null) {
for (String temp : ipsTemps) {
ips.add(temp);
}
}
String xml = StringUtils.getStringFromPage(pageResult, "<data>", "</data>");
reports.add(ReportUtils.parseFailureReportXML(xml));
}else{
reports.add(new FailureReport());
}
}
FailureReport result = ReportUtils.mergeFailureReports(reports);
List<String> domainList = new ArrayList<String>(domains);
List<String> ipList = new ArrayList<String>(ips);
Collections.sort(domainList);
Collections.sort(ipList);
model.setDomains(domainList);
model.setIps(ipList);
currentDomain = result.getDomain();
model.setCurrentDomain(currentDomain);
currentIp = result.getMachine();
model.setCurrentIp(currentIp);
model.setJsonResult(new DefaultJsonBuilder().buildJson(result));
model.setGenerateTime(DateUtils.SDF_SEG.format(new Date()));
} else {
// TODO
model.setGenerateTime(DateUtils.SDF_SEG.format(new Date(reportStart + DateUtils.HOUR)));
String reportFileName = m_manager.getReportStoreFile(reportStart, payload.getDomain(), payload.getIp());
model.setCurrentDomain(payload.getDomain());
model.setCurrentIp(payload.getIp());
System.out.println(reportFileName);
}
model.setUrlPrefix(m_manager.getBaseUrl(currentDomain, currentIp, reportCurrentTime));
model.setReportTitle(m_manager.getReportDisplayTitle(model.getCurrentDomain(), model.getCurrentIp(), reportStart));
m_jspViewer.view(ctx, model);
}
}
package com.dianping.cat.report.page.failure;
public enum JspFile {
VIEW("/jsp/report/failure.jsp"),
;
private String m_path;
private JspFile(String path) {
m_path = path;
}
public String getPath() {
return m_path;
}
}
package com.dianping.cat.report.page.failure;
import com.dianping.cat.report.ReportPage;
import com.site.web.mvc.view.BaseJspViewer;
public class JspViewer extends BaseJspViewer<ReportPage, Action, Context, Model> {
@Override
protected String getJspFilePath(Context ctx, Model model) {
Action action = model.getAction();
switch (action) {
case VIEW:
return JspFile.VIEW.getPath();
}
throw new RuntimeException("Unknown action: " + action);
}
}
package com.dianping.cat.report.page.failure;
import java.util.ArrayList;
import java.util.List;
import com.dianping.cat.report.page.AbstractReportModel;
import com.dianping.cat.report.view.UrlNav;
public class Model extends AbstractReportModel<Action, Context> {
private String m_current;
private String m_currentDomain;
private String m_currentIp;
private List<String> m_domains;
private List<String> m_ips;
private String m_jsonResult;
private String m_reportTitle;
private String m_generateTime;
private String m_urlPrefix;
private List<UrlNav> m_urlNavs;
public Model(Context ctx) {
super(ctx);
m_urlNavs = new ArrayList<UrlNav>();
for (UrlNav temp : UrlNav.values()) {
m_urlNavs.add(temp);
}
}
public String getUrlPrefix() {
return m_urlPrefix;
}
public void setUrlPrefix(String urlPrefix) {
m_urlPrefix = urlPrefix;
}
public String getCurrent() {
return m_current;
}
public String getCurrentDomain() {
return m_currentDomain;
}
public String getCurrentIp() {
return m_currentIp;
}
@Override
public Action getDefaultAction() {
return Action.VIEW;
}
@Override
public String getDomain() {
return m_currentDomain;
}
public List<String> getDomains() {
return m_domains;
}
public List<String> getIps() {
return m_ips;
}
public String getJsonResult() {
return m_jsonResult;
}
public String getReportTitle() {
return m_reportTitle;
}
public void setCurrent(String current) {
this.m_current = current;
}
public void setCurrentDomain(String currentDomain) {
m_currentDomain = currentDomain;
}
public void setCurrentIp(String currentIp) {
m_currentIp = currentIp;
}
public void setDomains(List<String> domains) {
m_domains = domains;
}
public void setIps(List<String> ips) {
m_ips = ips;
}
public void setJsonResult(String jsonResult) {
m_jsonResult = jsonResult;
}
public void setReportTitle(String reportTitle) {
m_reportTitle = reportTitle;
}
public String getSimpleCurrentIp() {
return m_currentIp.replace(".", "");
}
public List<UrlNav> getUrlNavs() {
return m_urlNavs;
}
public void setUrlNavs(List<UrlNav> urlNavs) {
this.m_urlNavs = urlNavs;
}
public String getGenerateTime() {
return m_generateTime;
}
public void setGenerateTime(String generateTime) {
m_generateTime = generateTime;
}
}
package com.dianping.cat.report.page.failure;
import com.dianping.cat.report.ReportPage;
import com.site.web.mvc.ActionContext;
import com.site.web.mvc.ActionPayload;
import com.site.web.mvc.payload.annotation.FieldMeta;
public class Payload implements ActionPayload<ReportPage, Action> {
private ReportPage m_page;
@FieldMeta("op")
private Action m_action;
@FieldMeta("domain")
private String m_domain;
@FieldMeta("ip")
private String m_ip;
@FieldMeta("current")
private String m_current;
@FieldMeta("method")
private int m_method;
public void setAction(Action action) {
m_action = action;
}
@Override
public Action getAction() {
return m_action;
}
@Override
public ReportPage getPage() {
return m_page;
}
@Override
public void setPage(String page) {
m_page = ReportPage.getByName(page, ReportPage.FAILURE);
}
@Override
public void validate(ActionContext<?> ctx) {
}
public String getDomain() {
return m_domain;
}
public void setDomain(String domain) {
this.m_domain = domain;
}
public String getCurrent() {
return m_current;
}
public void setCurrent(String current) {
m_current = current;
}
public int getMethod() {
return m_method;
}
public void setMethod(int method) {
this.m_method = method;
}
public void setPage(ReportPage page) {
m_page = page;
}
public String getIp() {
return m_ip;
}
public void setIp(String ip) {
m_ip = ip;
}
}
package com.dianping.cat.report.page.model.failure;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
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.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultMerger;
import com.dianping.cat.report.page.model.spi.ModelRequest;
import com.dianping.cat.report.page.model.spi.ModelResponse;
import com.dianping.cat.report.page.model.spi.ModelService;
import com.site.lookup.annotation.Inject;
public class CompositeFailureModelService implements ModelService<FailureReport>, Initializable {
@Inject
private List<ModelService<FailureReport>> m_services;
private ExecutorService m_threadPool;
@Override
public void initialize() throws InitializationException {
m_threadPool = Executors.newFixedThreadPool(10);
}
@Override
public ModelResponse<FailureReport> invoke(final ModelRequest request) {
int size = m_services.size();
final List<ModelResponse<FailureReport>> responses = new ArrayList<ModelResponse<FailureReport>>(size);
final CountDownLatch latch = new CountDownLatch(size);
for (final ModelService<FailureReport> service : m_services) {
m_threadPool.submit(new Runnable() {
@Override
public void run() {
try {
responses.add(service.invoke(request));
} catch (Exception e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}
});
}
try {
latch.await(5000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
// ignore it
}
ModelResponse<FailureReport> aggregated = new ModelResponse<FailureReport>();
DefaultMerger merger = null;
for (ModelResponse<FailureReport> response : responses) {
if (response != null) {
FailureReport model = response.getModel();
if (model != null) {
if (merger == null) {
merger = new DefaultMerger(model);
} else {
model.accept(merger);
}
}
}
}
aggregated.setModel(merger == null ? null : merger.getFailureReport());
return aggregated;
}
@Override
public boolean isEligable(ModelRequest request) {
for (ModelService<FailureReport> service : m_services) {
if (service.isEligable(request)) {
return true;
}
}
return false;
}
public void setSerivces(ModelService<FailureReport>... services) {
m_services = Arrays.asList(services);
}
}
package com.dianping.cat.report.page.model.failure;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.dianping.cat.consumer.RealtimeConsumer;
import com.dianping.cat.consumer.failure.FailureReportAnalyzer;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.message.spi.MessageConsumer;
import com.dianping.cat.report.page.model.spi.ModelPeriod;
import com.dianping.cat.report.page.model.spi.ModelRequest;
import com.dianping.cat.report.page.model.spi.ModelResponse;
import com.dianping.cat.report.page.model.spi.ModelService;
import com.site.lookup.annotation.Inject;
public class LocalFailureModelService implements ModelService<FailureReport> {
@Inject(type = MessageConsumer.class, value = "realtime")
private RealtimeConsumer m_consumer;
@Override
public ModelResponse<FailureReport> invoke(ModelRequest request) {
FailureReportAnalyzer analyzer = getAnalyzer(request.getPeriod());
ModelResponse<FailureReport> response = new ModelResponse<FailureReport>();
if (analyzer != null) {
Map<String, FailureReport> reports = analyzer.getReports();
List<String> domains = getDomains(reports.keySet());
String d = request.getDomain();
FailureReport report = reports.get(d != null ? d : domains.isEmpty() ? null : domains.get(0));
if (report != null) {
for (String domain : domains) {
report.addDomain(domain);
}
}
response.setModel(report);
}
return response;
}
public List<String> getDomains(Set<String> keys) {
List<String> domains = new ArrayList<String>(keys);
Collections.sort(domains, new Comparator<String>() {
@Override
public int compare(String d1, String d2) {
if (d1.equals("Cat")) {
return 1;
}
return d1.compareTo(d2);
}
});
return domains;
}
private FailureReportAnalyzer getAnalyzer(ModelPeriod period) {
if (period.isCurrent() || period.isFuture()) {
return (FailureReportAnalyzer) m_consumer.getCurrentAnalyzer("failure");
} else if (period.isLast()) {
return (FailureReportAnalyzer) m_consumer.getLastAnalyzer("failure");
} else {
return null;
}
}
@Override
public boolean isEligable(ModelRequest request) {
ModelPeriod period = request.getPeriod();
return !period.isHistorical();
}
}
package com.dianping.cat.report.page.model.failure;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.Map.Entry;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.transform.DefaultXmlParser;
import com.dianping.cat.report.page.model.spi.ModelPeriod;
import com.dianping.cat.report.page.model.spi.ModelRequest;
import com.dianping.cat.report.page.model.spi.ModelResponse;
import com.dianping.cat.report.page.model.spi.ModelService;
import com.site.helper.Files;
import com.site.helper.Joiners;
import com.site.helper.Joiners.IBuilder;
import com.site.lookup.annotation.Inject;
public class RemoteFailureModelService implements ModelService<FailureReport> {
@Inject
private String m_host;
@Inject
private int m_port = 2281; // default admin port
@Inject
private String m_serviceUri = "/cat/r/model";
URL buildUrl(ModelRequest request) throws MalformedURLException {
String pairs = Joiners.by('&').prefixDelimiter()
.join(request.getProperties().entrySet(), new IBuilder<Map.Entry<String, String>>() {
@Override
public String asString(Entry<String, String> e) {
return e.getKey() + "=" + e.getValue();
}
});
String url = String.format("http://%s:%s%s/%s/%s/%s?op=xml%s", m_host, m_port, m_serviceUri, "failure",
request.getDomain(), request.getPeriod(), pairs);
return new URL(url);
}
@Override
public ModelResponse<FailureReport> invoke(ModelRequest request) {
ModelResponse<FailureReport> response = new ModelResponse<FailureReport>();
try {
URL url = buildUrl(request);
String xml = Files.forIO().readFrom(url.openStream(), "utf-8");
if (xml != null && xml.trim().length() > 0) {
FailureReport report = new DefaultXmlParser().parse(xml);
response.setModel(report);
}
} catch (Exception e) {
response.setException(e);
}
return response;
}
@Override
public boolean isEligable(ModelRequest request) {
ModelPeriod period = request.getPeriod();
return period.isCurrent() || period.isLast();
}
public void setHost(String host) {
m_host = host;
}
public void setPort(int port) {
m_port = port;
}
public void setServiceUri(String serviceUri) {
m_serviceUri = serviceUri;
}
}
package com.dianping.cat.report.page.service;
public enum Action implements com.site.web.mvc.Action {
VIEW("view");
private String m_name;
private Action(String name) {
m_name = name;
}
public static Action getByName(String name, Action defaultAction) {
for (Action action : Action.values()) {
if (action.getName().equals(name)) {
return action;
}
}
return defaultAction;
}
@Override
public String getName() {
return m_name;
}
}
package com.dianping.cat.report.page.service;
import com.dianping.cat.report.ReportContext;
public class Context extends ReportContext<Payload> {
}
package com.dianping.cat.report.page.service;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletException;
import com.dianping.cat.report.ReportPage;
import com.dianping.cat.report.page.service.provider.FailureModelProvider;
import com.dianping.cat.report.page.service.provider.ModelProvider;
import com.dianping.cat.report.tool.Constants;
import com.site.lookup.annotation.Inject;
import com.site.web.mvc.PageHandler;
import com.site.web.mvc.annotation.InboundActionMeta;
import com.site.web.mvc.annotation.OutboundActionMeta;
import com.site.web.mvc.annotation.PayloadMeta;
public class Handler implements PageHandler<Context> {
@Inject
private JspViewer m_jspViewer;
@Inject(type = ModelProvider.class, value = "failure")
private ModelProvider m_failureModel;
@Inject(type = ModelProvider.class, value = "transaction")
private ModelProvider m_transactionModel;
@Inject(type = ModelProvider.class, value = "ip")
private ModelProvider m_ipModel;
@Override
@PayloadMeta(Payload.class)
@InboundActionMeta(name = "service")
public void handleInbound(Context ctx) throws ServletException, IOException {
// display only, no action here
}
@Override
@OutboundActionMeta(name = "service")
public void handleOutbound(Context ctx) throws ServletException, IOException {
Model model = new Model(ctx);
Payload payload = ctx.getPayload();
model.setAction(Action.VIEW);
model.setPage(ReportPage.SERVICE);
String index = payload.getIndex();
String modelStr = payload.getModel();
String domain = payload.getDomain();
if (modelStr == null || modelStr.equals(Constants.FAILURE)) {
String domains = getDomains(m_failureModel);
model.setDomains(domains);
if (null == domain) {
domain = m_failureModel.getDefaultDomain();
}
FailureModelProvider provider = (FailureModelProvider) m_failureModel;
String ips = getFailureIps(provider, domain);
model.setIps(ips);
String ip = payload.getIp();
if (null == ip) {
ip = provider.getDefaultIpByDomain(domain);
}
if (ip != null && domain != null) {
String xmlData = getModelXMLData(domain, ip, index, m_failureModel);
model.setXmlData(xmlData);
} else {
model.setXmlData("No domain or no ip in failure report!");
}
} else if (modelStr.equals(Constants.TRANSACTION)) {
String domains = getDomains(m_transactionModel);
model.setDomains(domains);
if (null == domain) {
domain = m_transactionModel.getDefaultDomain();
}
if (null != domain) {
String xmlData = getModelXMLData(domain, "", index, m_transactionModel);
model.setXmlData(xmlData);
} else {
model.setXmlData("No domain in transaction report!");
}
} else if (modelStr.equalsIgnoreCase("ip")) {
String domains = getDomains(m_ipModel);
model.setDomains(domains);
if (null == domain) {
domain = m_ipModel.getDefaultDomain();
}
if (null != domain) {
String xmlData = getModelXMLData(domain, "", index, m_ipModel);
model.setXmlData(xmlData);
} else {
model.setXmlData("No domain in ip report!");
}
}
m_jspViewer.view(ctx, model);
}
private String getFailureIps(FailureModelProvider failureModel, String domain) {
List<String> ips = failureModel.getIpsByDomain(domain);
Collections.sort(ips);
StringBuffer ipsBuffer = new StringBuffer();
for (String temp : ips) {
ipsBuffer.append(temp).append("\t");
}
return ipsBuffer.toString();
}
private String getDomains(ModelProvider provider) {
List<String> domains = provider.getDomains();
Collections.sort(domains);
StringBuffer domainsBuffer = new StringBuffer();
for (String temp : domains) {
domainsBuffer.append(temp).append("\t");
}
return domainsBuffer.toString();
}
private String getModelXMLData(String domain, String ip, String index, ModelProvider provider) {
if (index == null) {
index = Constants.MEMORY_CURRENT;
}
if (index.equals(Constants.MEMORY_CURRENT) || index.equals(Constants.MEMORY_LAST)) {
Map<String, String> map = new HashMap<String, String>();
map.put("domain", domain);
map.put("ip", ip);
map.put("index", index);
return provider.getModel(map);
}
return null;
}
}
package com.dianping.cat.report.page.service;
public enum JspFile {
VIEW("/jsp/report/service.jsp"),
;
private String m_path;
private JspFile(String path) {
m_path = path;
}
public String getPath() {
return m_path;
}
}
package com.dianping.cat.report.page.service;
import com.dianping.cat.report.ReportPage;
import com.site.web.mvc.view.BaseJspViewer;
public class JspViewer extends BaseJspViewer<ReportPage, Action, Context, Model> {
@Override
protected String getJspFilePath(Context ctx, Model model) {
Action action = model.getAction();
switch (action) {
case VIEW:
return JspFile.VIEW.getPath();
}
throw new RuntimeException("Unknown action: " + action);
}
}
package com.dianping.cat.report.page.service;
import com.dianping.cat.report.ReportPage;
import com.site.web.mvc.ViewModel;
public class Model extends ViewModel<ReportPage, Action, Context> {
private String m_xmlData;
private String m_domains;
private String m_ips;
public String getXmlData() {
return m_xmlData;
}
public void setXmlData(String xmlData) {
m_xmlData = xmlData;
}
public Model(Context ctx) {
super(ctx);
}
public String getDomains() {
return m_domains;
}
public void setDomains(String domains) {
m_domains = domains;
}
public String getIps() {
return m_ips;
}
public void setIps(String ips) {
m_ips = ips;
}
@Override
public Action getDefaultAction() {
return Action.VIEW;
}
}
package com.dianping.cat.report.page.service;
import com.dianping.cat.report.ReportPage;
import com.site.web.mvc.ActionContext;
import com.site.web.mvc.ActionPayload;
import com.site.web.mvc.payload.annotation.FieldMeta;
public class Payload implements ActionPayload<ReportPage, Action> {
private ReportPage m_page;
@FieldMeta("op")
private Action m_action;
@FieldMeta("domain")
private String m_domain;
@FieldMeta("ip")
private String m_ip;
@FieldMeta("index")
private String m_index;
@FieldMeta("model")
private String m_model;
@Override
public Action getAction() {
return m_action;
}
@Override
public ReportPage getPage() {
return m_page;
}
public String getDomain() {
return m_domain;
}
public void setDomain(String domain) {
m_domain = domain;
}
public String getIp() {
return m_ip;
}
public void setIp(String ip) {
m_ip = ip;
}
public String getIndex() {
return m_index;
}
public void setIndex(String index) {
m_index = index;
}
public String getModel() {
return m_model;
}
public void setModel(String model) {
m_model = model;
}
public void setPage(ReportPage page) {
m_page = page;
}
public void setAction(Action action) {
m_action = action;
}
@Override
public void setPage(String page) {
m_page = ReportPage.getByName(page, ReportPage.SERVICE);
}
@Override
public void validate(ActionContext<?> ctx) {
}
}
package com.dianping.cat.report.page.service.provider;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import com.dianping.cat.consumer.RealtimeConsumer;
import com.dianping.cat.consumer.failure.FailureReportAnalyzer;
import com.dianping.cat.consumer.failure.model.entity.FailureReport;
import com.dianping.cat.consumer.failure.model.entity.Segment;
import com.dianping.cat.consumer.failure.model.entity.Threads;
import com.dianping.cat.consumer.failure.model.transform.DefaultXmlBuilder;
import com.dianping.cat.message.spi.MessageConsumer;
import com.dianping.cat.report.tool.Constants;
import com.dianping.cat.report.tool.DateUtils;
import com.site.lookup.annotation.Inject;
public class FailureModelProvider implements ModelProvider {
@Inject(type = MessageConsumer.class, value = "realtime")
private RealtimeConsumer m_consumer;
@Override
public List<String> getDomains() {
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) m_consumer.getCurrentAnalyzer("failure");
List<String> domains = analyzer.getAllDomains();
Collections.sort(domains, new Comparator<String>() {
@Override
public int compare(String d1, String d2) {
if (d1.equals("Cat")) {
return 1;
}
return d1.compareTo(d2);
}
});
return domains;
}
@Override
public String getModel(Map<String, String> parameters) {
String index = parameters.get("index");
if (index == null) {
index = Constants.MEMORY_CURRENT;
}
String domain = parameters.get("domain");
String ip = parameters.get("ip");
FailureReportAnalyzer analyzer = null;
int pos = Constants.LAST;
if (index.equals(Constants.MEMORY_CURRENT)) {
analyzer = (FailureReportAnalyzer) m_consumer.getCurrentAnalyzer("failure");
pos = Constants.CURRENT;
} else if (index.equals(Constants.MEMORY_LAST)) {
analyzer = (FailureReportAnalyzer) m_consumer.getLastAnalyzer("failure");
pos = Constants.LAST;
}
String xmlResult = "";
if (analyzer == null) {
xmlResult = getFailureDataByNew(pos, domain, ip);
} else {
xmlResult = getFailureDataFromMemory(analyzer, domain, ip);
}
return xmlResult;
}
public List<String> getIpsByDomain(String domain) {
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) m_consumer.getCurrentAnalyzer("failure");
List<String> ips = analyzer.getHostIpByDomain(domain);
Collections.sort(ips);
return ips;
}
private String getFailureXMLData(FailureReport report) {
return new DefaultXmlBuilder().buildXml(report);
}
private String getFailureDataFromMemory(FailureReportAnalyzer analyzer, String domain, String ip) {
FailureReport report = analyzer.generateByDomainAndIp(domain, ip);
return getFailureXMLData(report);
}
/*
* private String getFailureDataFromFile(String basePath, String file) {
* String result = ""; try { result = Files.forIO().readFrom(new
* File(basePath + file), "utf-8"); result =
* result.substring(result.indexOf("<body>") + 6, result.indexOf("</body>"));
* } catch (IOException e) { e.printStackTrace(); } return result; }
*/
private String getFailureDataByNew(int pos, String domain, String ip) {
long currentTime = System.currentTimeMillis();
long currentStart = currentTime - currentTime % DateUtils.HOUR;
long lastStart = currentTime - currentTime % DateUtils.HOUR - DateUtils.HOUR;
Date date = new Date();
if (pos == Constants.CURRENT) {
date.setTime(currentStart);
} else {
date.setTime(lastStart);
}
FailureReport report = new FailureReport();
report.setMachine(ip);
report.setThreads(new Threads());
report.setStartTime(date);
report.setEndTime(new Date(date.getTime() + DateUtils.HOUR - DateUtils.MINUTE));
report.setDomain(domain);
long start = report.getStartTime().getTime();
long endTime = report.getEndTime().getTime();
Map<String, Segment> segments = report.getSegments();
for (; start <= endTime; start = start + 60 * 1000) {
String minute = DateUtils.SDF_SEG.format(new Date(start));
segments.put(minute, new Segment(minute));
}
return getFailureXMLData(report);
}
@Override
public String getDefaultDomain() {
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) m_consumer.getCurrentAnalyzer("failure");
List<String> domains = analyzer.getAllDomains();
Collections.sort(domains);
if (domains != null && domains.size() > 0) {
return domains.get(0);
}
return null;
}
public String getDefaultIpByDomain(String domain){
FailureReportAnalyzer analyzer = (FailureReportAnalyzer) m_consumer.getCurrentAnalyzer("failure");
List<String> ips = analyzer.getHostIpByDomain(domain);
if(ips!=null&&ips.size()>0){
return ips.get(0);
}
return null;
}
}
package com.dianping.cat.report.page.service.provider;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import com.dianping.cat.consumer.RealtimeConsumer;
import com.dianping.cat.consumer.ip.IpAnalyzer;
import com.dianping.cat.consumer.ip.model.entity.IpReport;
import com.dianping.cat.consumer.ip.model.transform.DefaultXmlBuilder;
import com.dianping.cat.message.spi.MessageConsumer;
import com.dianping.cat.report.tool.Constants;
import com.site.lookup.annotation.Inject;
public class IpModelProvider implements ModelProvider {
@Inject(type = MessageConsumer.class, value = "realtime")
private RealtimeConsumer m_consumer;
@Override
public String getDefaultDomain() {
IpAnalyzer analyzer = (IpAnalyzer) m_consumer.getCurrentAnalyzer("ip");
List<String> domains = analyzer.getDomains();
Collections.sort(domains);
if (domains != null && domains.size() > 0) {
return domains.get(0);
}
return null;
}
@Override
public List<String> getDomains() {
IpAnalyzer analyzer = (IpAnalyzer) m_consumer.getCurrentAnalyzer("ip");
List<String> domains = analyzer.getDomains();
Collections.sort(domains, new Comparator<String>() {
@Override
public int compare(String d1, String d2) {
if (d1.equals("Cat")) {
return 1;
}
return d1.compareTo(d2);
}
});
return domains;
}
@Override
public String getModel(Map<String, String> parameters) {
String domain = parameters.get("domain");
String index = parameters.get("index");
IpAnalyzer analyzer = null;
if (index == null) {
index = Constants.MEMORY_CURRENT;
}
if (index.equals(Constants.MEMORY_CURRENT)) {
analyzer = (IpAnalyzer) m_consumer.getCurrentAnalyzer("ip");
} else if (index.equals(Constants.MEMORY_LAST)) {
analyzer = (IpAnalyzer) m_consumer.getLastAnalyzer("ip");
}
IpReport report = analyzer.generate(domain);
return new DefaultXmlBuilder().buildXml(report);
}
}
package com.dianping.cat.report.page.service.provider;
import java.util.List;
import java.util.Map;
public interface ModelProvider {
public String getModel(Map<String,String> parameters);
public List<String> getDomains();
public String getDefaultDomain();
}
package com.dianping.cat.report.page.service.provider;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import com.dianping.cat.consumer.RealtimeConsumer;
import com.dianping.cat.consumer.transaction.TransactionAnalyzer;
import com.dianping.cat.consumer.transaction.model.entity.TransactionReport;
import com.dianping.cat.consumer.transaction.model.transform.DefaultXmlBuilder;
import com.dianping.cat.message.spi.MessageConsumer;
import com.dianping.cat.report.tool.Constants;
import com.site.lookup.annotation.Inject;
public class TransactionModelProvider implements ModelProvider {
@Inject(type = MessageConsumer.class, value = "realtime")
private RealtimeConsumer m_consumer;
@Override
public List<String> getDomains() {
TransactionAnalyzer analyzer = (TransactionAnalyzer) m_consumer.getCurrentAnalyzer("transaction");
List<String> domains = new ArrayList<String>(analyzer.getReports().keySet());
Collections.sort(domains, new Comparator<String>() {
@Override
public int compare(String d1, String d2) {
if (d1.equals("Cat")) {
return 1;
}
return d1.compareTo(d2);
}
});
return domains;
}
@Override
public String getModel(Map<String, String> parameters) {
String domain = parameters.get("domain");
String index = parameters.get("index");
TransactionAnalyzer analyzer = null;
if (index == null) {
index = Constants.MEMORY_CURRENT;
}
if (index.equals(Constants.MEMORY_CURRENT)) {
analyzer = (TransactionAnalyzer) m_consumer.getCurrentAnalyzer("transaction");
} else if (index.equals(Constants.MEMORY_LAST)) {
analyzer = (TransactionAnalyzer) m_consumer.getLastAnalyzer("transaction");
} else {
System.err.println("historical model is not implemented yet");
}
TransactionReport report;
if (analyzer == null) {
report = new TransactionReport(domain);
} else {
report = analyzer.generate(domain);
}
return new DefaultXmlBuilder().buildXml(report);
}
@Override
public String getDefaultDomain() {
TransactionAnalyzer analyzer = (TransactionAnalyzer) m_consumer.getCurrentAnalyzer("transaction");
List<String> domains = new ArrayList<String>(analyzer.getReports().keySet());
Collections.sort(domains);
if (domains != null && domains.size() > 0) {
return domains.get(0);
}
return null;
}
}
package com.dianping.cat.report.page.transaction;
import java.util.Date;
import com.dianping.cat.report.ReportManager;
import com.dianping.cat.report.tool.DateUtils;
public class TransactionManager extends ReportManager{
public String getConnectionUrl(String server,String domain, String duration){
StringBuffer result = new StringBuffer("http://").append(server).append("/cat/r/service?model=transaction");
if (domain != null && domain.length() > 0) {
result.append("&").append("domain=").append(domain);
}
if (duration != null && duration.length() > 0) {
result.append("&").append("index=").append(duration);
}
return result.toString();
}
public String getReportStoreFile (long startHour, String domain){
long hour = DateUtils.HOUR;
long second = DateUtils.SECOND;
StringBuilder result = new StringBuilder();
result.append(domain).append("-").append(DateUtils.SDF_URL.format(new Date(startHour))).append("-")
.append(DateUtils.SDF_URL.format(new Date(startHour + hour - second * 60))).append(".html");
return result.toString();
}
public String getReportDisplayTitle (String domain, long startHour){
long currentTimeMillis = System.currentTimeMillis();
long end = startHour + DateUtils.HOUR - DateUtils.SECOND;
if (end > currentTimeMillis) {
end = currentTimeMillis;
}
StringBuilder title = new StringBuilder().append("Domain:").append(domain);
title.append(" From ").append(DateUtils.SDF_SEG.format(new Date(startHour))).append(" To ").append(
DateUtils.SDF_SEG.format(new Date(end)));
return title.toString();
}
public String getBaseUrl(String currentDomain, String reportCurrentTime) {
StringBuffer urlPrefix = new StringBuffer("?domain=");
urlPrefix.append(currentDomain).append("&current=").append(reportCurrentTime).append("&method=");
return urlPrefix.toString();
}
}
......@@ -5,26 +5,20 @@
<page name="home" title="Home" default="true">
<description>CAT Home Page.</description>
</page>
<page name="transaction" title="Transaction" path="t">
<description>CAT summary report for Transactions in current hour.</description>
<page name="problem" title="Problem" path="p">
<description>Problem discovered</description>
</page>
<page name="failure" title="Failure" path="f">
<description>CAT details report for failed messages in current hour.</description>
<page name="transaction" title="Transaction" path="t">
<description>Transaction summary report</description>
</page>
<page name="logview" title="Logview" path="m" standalone="false">
<description>CAT log details view for a given message.</description>
<description>Log view details</description>
</page>
<page name="ip" title="Top IP List">
<description>Top visited IP list in current hour.</description>
</page>
<page name="service" title="Service" path="service" standalone="false">
<description>Service Home</description>
<description>Top visited IP addresses</description>
</page>
<page name="model" title="Model" path="model" standalone="false">
<description>Model Service</description>
</page>
<page name="problem" title="Problem" path="p">
<description>Problem</description>
<description>Service model</description>
</page>
</module>
</webapp>
......
......@@ -101,7 +101,7 @@ public class SimpleServer extends SimpleServerSupport {
@Test
public void startServer() throws Exception {
// open the page in the default browser
//s_adaptor.display("/cat/r");
s_adaptor.display("/cat/r");
System.out.println(String.format("[%s] Press any key to stop server ... ", getTimestamp()));
System.in.read();
......
......@@ -21,6 +21,7 @@
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
......
/**
*
*/
package com.dianping.cat.job.hdfs;
import java.io.File;
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册