Java SpotterResult.setDetected方法代碼示例

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {

	SpotterResult result = new SpotterResult();
	String message = "Detected a test bottleneck!";

	String methodA = "methodA()";
	ProblemOccurrence occurrenceA = new ProblemOccurrence(methodA, message);
	String methodB = "methodB()";
	ProblemOccurrence occurrenceB = new ProblemOccurrence(methodB, message);
	String methodC = "methodC()";
	ProblemOccurrence occurrenceC = new ProblemOccurrence(methodC, message);

	result.addProblemOccurrence(occurrenceA);
	result.addProblemOccurrence(occurrenceB);
	result.addProblemOccurrence(occurrenceC);

	result.setDetected(true);
	result.addMessage("Test detection run finished successfully!");

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
public SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();

	Dataset rtDataset = data.getDataSets(ResponseTimeRecord.class).get(0);
	if (rtDataset == null || rtDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no results for the given scope!");
		return result;
	}
	for (String operation : rtDataset.getValueSet(ResponseTimeRecord.PAR_OPERATION, String.class)) {

		boolean operationDetected = analyseOperationResponseTimes(rtDataset, operation, result);
		if (operationDetected) {
			result.setDetected(true);
			result.addMessage("Ramp detected in operation: " + operation);
		}

	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@BeforeClass
public static void initProblems() {
	problemA = new PerformanceProblem("problemA");
	problemA.setProblemName("problemA");
	resultA = new SpotterResult();
	resultA.setDetected(true);

	problemB = new PerformanceProblem("problemB");
	problemB.setProblemName("problemB");
	resultB = new SpotterResult();
	resultB.setDetected(true);

	problemC = new PerformanceProblem("problemC");
	problemC.setProblemName("problemC");
	resultC = new SpotterResult();
	resultC.setDetected(false);

}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Test
public void testChartStorage() throws IOException {

	XChartBuilder chartBuilder = new XChartBuilder();
	chartBuilder.startChart("a", "b", "c");
	NumericPairList<Double, Double> pairList = new NumericPairList<>();
	pairList.add(1.0,2.0);
	pairList.add(2.0,5.0);
	pairList.add(3.0,7.0);
	chartBuilder.addScatterSeries(pairList, "test");
	DetectionResultManager drManager = new DetectionResultManager(CONTROLLER_NAME);
	drManager.setProblemId(CONTROLLER_NAME);
	String fileName = "chart";
	SpotterResult result = new SpotterResult();
	result.setDetected(true);
	drManager.storeImageChartResource(chartBuilder, fileName, result);

	Assert.assertEquals(1, result.getResourceFiles().size());
	String file = "1-" + fileName + ".png";
	Assert.assertEquals(file, result.getResourceFiles().get(0));

	File pngFile = new File(baseDir + RESOURCES_DIR + file);
	Assert.assertTrue(pngFile.isFile());
	Assert.assertTrue(pngFile.exists());
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
public SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();
	result.setDetected(false);

	Dataset rtDataset = data.getDataSet(ResponseTimeRecord.class);

	if (rtDataset == null || rtDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no results for the given scope!");
		return result;
	}

	for (String operation : rtDataset.getValueSet(ResponseTimeRecord.PAR_OPERATION, String.class)) {
		ParameterSelection selectOperation = new ParameterSelection().select(ResponseTimeRecord.PAR_OPERATION,
				operation);
		Dataset operationSpecificDataset = selectOperation.applyTo(rtDataset);

		NumericPairList<Long, Double> responseTimeSeries = Utils.toTimestampRTPairs(operationSpecificDataset);
		// sort chronologically
		responseTimeSeries.sort();

		SimpleRegression regression = LpeNumericUtils.linearRegression(responseTimeSeries);

		double slope = regression.getSlope();
		if (slope > slopeThreshold) {
			result.addMessage("Ramp detected in operation: " + operation);
			result.setDetected(true);
		}

		createChart(result, operation, responseTimeSeries, regression);
	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {
	LOGGER.debug("Analyze data for GodClass Antipattern..");

	SpotterResult result = new SpotterResult();
	result.setDetected(false);

	/** Process the raw measurement data */
	LOGGER.debug("process data..");
	ProcessedData processData = DataProcessor.processData(data);

	/** Analyze the processed data */
	LOGGER.debug("analyze data..");

	List<Component> blobs = analysisStrategyImpl.analyze(processData, getResultManager(), result);

	if (!blobs.isEmpty()) {
		result.setDetected(true);
		int i = 1;
		for (Component blob : blobs) {
			result.addMessage("Blob Component:");
			result.addMessage("CP " + i + ": " + blob.getId());
			result.addMessage("");
			result.addMessage("");
			result.addMessage("");
			i++;
		}

	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
private void newAnalysis(ProcessedData processData, SpotterResult result) {
	for (Component outer : processData.getComponents()) {
		result.addMessage("Investigated component: " + outer.getId());

		List<Double> pctMsgReceivedList = new ArrayList<Double>();
		for (Component inner : processData.getComponents()) {
			if (inner == outer) {
				continue;
			}
			pctMsgReceivedList.add(getRelativeReceivePct(inner));
		}

		double currentMean = LpeNumericUtils.average(pctMsgReceivedList);
		double standardDeviation = LpeNumericUtils.stdDev(pctMsgReceivedList);

		result.addMessage("Component Pct Messages Sent:   " + df.format(getRelativeReceivePct(outer)) + "$");
		result.addMessage("Current Mean:   " + df.format(currentMean) + "$");
		result.addMessage("Current StdDev: " + df.format(standardDeviation) + "%");
		result.addMessage("Critical Threshold (Mean + 3 * SD): "
				+ df.format(currentMean + THREE_SIGMA * standardDeviation) + "%");

		if (currentMean + THREE_SIGMA * standardDeviation < getRelativeReceivePct(outer)) {
			result.addMessage("Result: As GodClass detected");
			result.setDetected(true);
		} else {
			result.addMessage("Result: not detected");
		}
		result.addMessage("* * * *");
	}
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();

	Dataset rtDataset = data.getDataSet(ResponseTimeRecord.class);

	if (rtDataset == null || rtDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no results for the given scope!");
		return result;
	}

	for (String operation : rtDataset.getValueSet(ResponseTimeRecord.PAR_OPERATION, String.class)) {

		boolean operationDetected = false;
		try {
			operationDetected = analysisStrategyImpl.analyseOperationResponseTimes(rtDataset, operation, result);
		} catch (NullPointerException npe) {
			result.addMessage("Traffic Jam detection failed for the operation '" + operation
					+ "', because the operation was not executed in each analysis cycle.");
			continue;
		} catch (IllegalArgumentException iae) {
			result.addMessage(iae.getMessage());
			continue;
		}

		if (operationDetected) {
			result.setDetected(true);
			result.addMessage("Traffic Jam detected in service: " + operation);

		}

	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
/**
 * Marks all children of parent recursively as not detected.
 * 
 * @param parent
 *            the parent problem to start with
 */
private void addNotDetectedChildrenRecursively(PerformanceProblem parent) {
	for (PerformanceProblem child : parent.getChildren()) {

		ProgressManager.getInstance().updateProgressStatus(child.getUniqueId(), DiagnosisStatus.NOT_DETECTED);
		ProgressManager.getInstance().updateProgress(child.getUniqueId(), 1, 0);
		SpotterResult result = new SpotterResult();
		result.setDetected(false);
		ResultBlackboard.getInstance().putResult(child, result);

		addNotDetectedChildrenRecursively(child);

	}
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();
	result.setDetected(data.getRecords().size() == NUM_EXPERIMENTS * DummyMeasurement.NUM_RECORDS);

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();
	result.setDetected(true);
	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
public SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();
	result.setDetected(false);

	Dataset rtDataset = data.getDataSet(ResponseTimeRecord.class);

	if (rtDataset == null || rtDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no results for the given scope!");
		return result;
	}

	for (String operation : rtDataset.getValueSet(ResponseTimeRecord.PAR_OPERATION, String.class)) {
		ParameterSelection selectOperation = new ParameterSelection().select(ResponseTimeRecord.PAR_OPERATION,
				operation);
		Dataset operationSpecificDataset = selectOperation.applyTo(rtDataset);

		NumericPairList<Long, Double> responseTimeSeries = Utils.toTimestampRTPairs(operationSpecificDataset);
		// sort chronologically
		responseTimeSeries.sort();
		long minTimestamp = responseTimeSeries.getKeyMin();
		long diff = responseTimeSeries.getKeyMax() - responseTimeSeries.getKeyMin();
		long midTimestamp = minTimestamp + (diff) / 2L;

		List<Double> firstHalf = new ArrayList<>();
		List<Double> secondHalf = new ArrayList<>();
		for (NumericPair<Long, Double> valuePair : responseTimeSeries) {
			if (valuePair.getKey() < midTimestamp) {
				firstHalf.add(valuePair.getValue());
			} else {
				secondHalf.add(valuePair.getValue());
			}
		}

		List<Double> sums1 = new ArrayList<>();
		List<Double> sums2 = new ArrayList<>();
		LpeNumericUtils.createNormalDistributionByBootstrapping(firstHalf, secondHalf, sums1, sums2);
		double firstMean = LpeNumericUtils.average(sums1);
		double secondMean = LpeNumericUtils.average(sums2);
		double pValue = LpeNumericUtils.tTest(sums1, sums2);
		if (pValue <= requiredSignificanceLevel && firstMean < secondMean) {
			result.addMessage("Ramp detected in operation: " + operation);
			result.setDetected(true);
		}
		createChart(result, operation, responseTimeSeries, minTimestamp, diff, sums1, sums2, firstMean, secondMean);

	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {
	long perfReqThreshold = GlobalConfiguration.getInstance().getPropertyAsInteger(
			ConfigKeys.PERFORMANCE_REQUIREMENT_THRESHOLD, ConfigKeys.DEFAULT_PERFORMANCE_REQUIREMENT_THRESHOLD);
	double perfReqConfidence = GlobalConfiguration.getInstance().getPropertyAsDouble(
			ConfigKeys.PERFORMANCE_REQUIREMENT_CONFIDENCE, ConfigKeys.DEFAULT_PERFORMANCE_REQUIREMENT_CONFIDENCE);

	SpotterResult result = new SpotterResult();
	result.setDetected(false);

	Dataset rtDataset = data.getDataSet(ResponseTimeRecord.class);

	if (rtDataset == null || rtDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no results for the given scope!");
		return result;
	}

	for (String operation : rtDataset.getValueSet(ResponseTimeRecord.PAR_OPERATION, String.class)) {
		ParameterSelection selectOperation = new ParameterSelection().select(ResponseTimeRecord.PAR_OPERATION,
				operation);
		Dataset operationSpecificDataset = selectOperation.applyTo(rtDataset);

		NumericPairList<Long, Double> responseTimeSeries = Utils.toTimestampRTPairs(operationSpecificDataset);
		if (responseTimeSeries.size() <= 5) {
			continue;
		}
		// sort chronologically
		responseTimeSeries.sort();
		List<Hiccup> hiccups = analysisStrategyImpl.findHiccups(responseTimeSeries, hiccupDetectionConfig,
				perfReqThreshold, perfReqConfidence, getResultManager(), result);

		long experimentDuration = responseTimeSeries.getKeyMax() - responseTimeSeries.getKeyMin();
		long hiccupsDuration = 0;
		for (Hiccup hiccup : hiccups) {
			hiccupsDuration += hiccup.getEndTimestamp() - hiccup.getStartTimestamp();
		}

		if (hiccups.size() > 1 && hiccupsDuration < maxHiccupTimeProportion * experimentDuration) {
			result.addMessage("Detected hiccup behaviour in operation: " + operation);
			result.setDetected(true);
			createChart(result, operation, responseTimeSeries, hiccups, perfReqThreshold);

		}

	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
protected SpotterResult analyze(DatasetCollection data) {

	LOGGER.info("Fetching datasets.");

	Dataset sqlDataset = data.getDataSet(SQLQueryRecord.class);
	Dataset rtDataset = data.getDataSet(ResponseTimeRecord.class);
	Dataset tracingDataset = data.getDataSet(ThreadTracingRecord.class);

	LOGGER.info("Converting SQL dataset.");

	List<SQLQueryRecord> sqlRecords = sqlDataset.getRecords(SQLQueryRecord.class);
	List<ThreadTracingRecord> ttRecords = tracingDataset.getRecords(ThreadTracingRecord.class);

	sqlRecords = filterQueryRecords(sqlRecords, ttRecords);

	LOGGER.info("Converting RT dataset.");

	List<ResponseTimeRecord> rtRecords = rtDataset.getRecords(ResponseTimeRecord.class);
	rtRecords = filterResponsetimeRecords(rtRecords);

	LOGGER.info("Analyzing datasets.");

	Map<String, List<StifleQuery>> stifleQueries = analyzeDatasets(rtRecords, sqlRecords);

	LOGGER.info("Creating results.");

	SpotterResult result = new SpotterResult();
	result.setDetected(false);

	if (!stifleQueries.isEmpty()) {
		result.setDetected(true);
		StringBuilder strBuilder = new StringBuilder();
		for (String operation : stifleQueries.keySet()) {
			strBuilder.append("Stifles in operation " + operation + " found:");
			strBuilder.append("\n");
			List<StifleQuery> stifles = stifleQueries.get(operation);
			for (StifleQuery stifle : stifles) {
				strBuilder.append("Query: " + stifle.getQuery());
				strBuilder.append("\n");
				strBuilder.append("occured: ( " + LpeNumericUtils.min(stifle.getOccurrences()) + " , "
						+ LpeNumericUtils.average(stifle.getOccurrences()) + " , "
						+ LpeNumericUtils.max(stifle.getOccurrences()) + " ) times");
				strBuilder.append("\n");
			}
			strBuilder.append("\n");
			strBuilder.append("\n");
		}
		result.addMessage(strBuilder.toString());
	}

	return result;
}
 

import org.spotter.shared.result.model.SpotterResult; //導入方法依賴的package包/類
@Override
public SpotterResult analyze(DatasetCollection data) {
	SpotterResult result = new SpotterResult();

	Dataset rtDataset = data.getDataSet(ResponseTimeRecord.class);

	if (rtDataset == null || rtDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no response time results for the given scope!");
		return result;
	}

	Dataset cpuUtilDataset = data.getDataSet(CPUUtilizationRecord.class);

	if (cpuUtilDataset == null || cpuUtilDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no CPU utilization results for the given scope!");
		return result;
	}

	Dataset networkInfoDataset = data.getDataSet(NetworkInterfaceInfoRecord.class);

	if (networkInfoDataset == null || networkInfoDataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no networkInfoDataset results for the given scope!");
		return result;
	}

	Dataset networkIODataset = data.getDataSet(NetworkRecord.class);

	if (networkIODataset == null || networkIODataset.size() == 0) {
		result.setDetected(false);
		result.addMessage("Instrumentation achieved no netowrk IO results for the given scope!");
		return result;
	}

	List<Integer> numUsersList = getNumUsersList(rtDataset);
	Map<String, NumericPairList<Integer, Double>> responseTimesMap = null;
	if (scope.equals(OLBExtension.DB_SCOPE)) {
		Dataset sqlDataset = data.getDataSet(SQLQueryRecord.class);

		if (sqlDataset == null || sqlDataset.size() == 0) {
			result.setDetected(false);
			result.addMessage("Instrumentation achieved no SQL results for the given scope!");
			return result;
		}

		responseTimesMap = getOperationResponseTimesWithSQL(rtDataset, sqlDataset, result, numUsersList);
	} else {
		responseTimesMap = getOperationResponseTimes(rtDataset, result, numUsersList);

	}
	Map<String, NumericPairList<Integer, Double>> utilsMap = getCPUUtilizations(cpuUtilDataset, result,
			numUsersList);

	utilsMap.putAll(getNetworkUtilizations(networkIODataset, networkInfoDataset, result, numUsersList));
	Map<String, Integer> numServersMap = getNumberOfCPUCores(cpuUtilDataset);
	numServersMap.putAll(getNumberServers(networkInfoDataset));

	// List<String> candidateOperations =
	// analyseResponseTimesIncrease(result, numUsersList, responseTimesMap);
	// Set<String> operations = new HashSet<>();
	// operations.addAll(responseTimesMap.keySet());
	// for (String operation : operations) {
	// if (!candidateOperations.contains(operation)) {
	// responseTimesMap.remove(operation);
	// }
	// }
	analyzeOLB(result, numUsersList, responseTimesMap, utilsMap, numServersMap);

	return result;
}