/**
* Returns the JSON string built by the builder. This is the JSON that can be used by the client
* add metrics.
*
* @return JSON
* @throws IOException if metrics cannot be converted to JSON
*/
public String build() throws IOException {
for (Metric metric : metrics) {
// verify that there is at least one tag for each metric
checkState(metric.getTags().size() > 0, metric.getName() + " must contain at least one tag.");
}
return mapper.toJson(metrics);
}
@Override
// @Secured TODO: we need to handle this property, since getTestByRelation will not work as metric
// is associated with more tests
public void removeMetric(Metric metric, Test test) throws ServiceException {
Metric freshMetric = metricDAO.get(metric.getId());
Test freshTest = testDAO.get(test.getId());
// List<Test> newTests = freshMetric.getTests().stream().filter(o ->
// !o.equals(freshTest)).collect(Collectors.toList());
// freshMetric.setTests(newTests);
// List<Metric> newMetrics = freshTest.getMetrics().stream().filter(o ->
// !o.equals(freshMetric)).collect(Collectors.toList());
// freshTest.setMetrics(newMetrics);
freshMetric.getTests().remove(freshTest);
freshTest.getMetrics().remove(freshMetric);
metricDAO.update(freshMetric);
testDAO.update(freshTest);
if (freshMetric.getTests() == null || freshMetric.getTests().isEmpty()) {
metricDAO.remove(freshMetric);
}
}
/**
* Calculates the k-means costs of the ClusteringFeature and another ClusteringFeature too a
* center.
*
* @param center the center too calculate the costs
* @param points the points too calculate the costs
* @return the costs
*/
public double calcKMeansCosts(double[] center, ClusteringFeature points) {
assert (this.sumPoints.length == center.length
&& this.sumPoints.length == points.sumPoints.length);
return (this.sumSquaredLength + points.sumSquaredLength)
- 2 * Metric.dotProductWithAddition(this.sumPoints, points.sumPoints, center)
+ (this.numPoints + points.numPoints) * Metric.dotProduct(center);
}
@Test
public void testToString() {
Metric m = new Metric();
String value = m.toString();
assertNotNull(value);
assertFalse(value.isEmpty());
}
@Test
public void tesNottEquals() {
Metric m1 = new Metric();
Metric m2 = new Metric();
m1.setFrom("from1");
m2.setFrom("from2");
assertFalse(m1.equals(m2));
}
public void entryUpdated(int statusesCount) {
thisHour.entriesInserted++;
thisMinute.entriesInserted++;
thisHour.statusesInserted += statusesCount;
thisMinute.statusesInserted += statusesCount;
}
/**
* Computes total quota allocations.
*
* @return Total allocated quota.
* @throws StorageException if there was a problem fetching quotas from storage.
*/
public Metric computeQuotaAllocationTotals() throws StorageException {
return storage.read(
storeProvider -> {
Metric allocation = new Metric();
for (IResourceAggregate quota : storeProvider.getQuotaStore().fetchQuotas().values()) {
allocation.accumulate(quota);
}
return allocation;
});
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Metric)) {
return false;
}
Metric other = (Metric) o;
return getCpu() == other.getCpu()
&& getRamGb() == other.getRamGb()
&& getDiskGb() == other.getDiskGb();
}
public void internalTestPerformance(Metric<double[]> metric, double[] value1, double[] value2)
throws IOException {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
for (int i = 0; i < 10000000; i++) {
metric.distance(value1, value2);
}
System.out.println(metric.getClass().getName() + ": " + stopWatch.meanTime());
}
@Override
@Secured
public Value addValue(Value value) throws ServiceException {
TestExecution exec = testExecutionDAO.get(value.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.addValue.testExecutionNotFound", value.getTestExecution().getName());
}
Metric metric = null;
if (value.getMetric().getId() != null) {
metric = metricDAO.get(value.getMetric().getId());
} else {
List<Metric> metrics =
metricDAO.getMetricByNameAndGroup(
value.getMetric().getName(), exec.getTest().getGroupId());
if (metrics.size() > 0) {
metric = metricDAO.get(metrics.get(0).getId());
}
}
if (metric == null) {
throw new ServiceException("serviceException.metricNotFound", value.getMetric().getName());
}
value.setTestExecution(exec);
value.setMetric(metric);
// check if other values for given metric exist, if yes, we can only add one if both old and new
// one have at least one parameter
List<Value> existingValuesForMetric = valueDAO.find(exec.getId(), metric.getId());
if (!existingValuesForMetric.isEmpty()) {
for (Value v : existingValuesForMetric) {
if (!v.hasParameters()) {
throw new ServiceException("serviceException.unparametrizedMultiValue");
}
}
if (!value.hasParameters()) {
throw new ServiceException("serviceException.unparametrizedMultiValue");
}
}
Value freshValue = valueDAO.create(value);
Value freshValueClone = freshValue.clone();
List<ValueParameter> newParams = new ArrayList<ValueParameter>();
if (value.hasParameters()) {
for (ValueParameter valueParameter : value.getParameters()) {
valueParameter.setValue(freshValue);
newParams.add(valueParameterDAO.create(valueParameter).clone());
newParams.get(newParams.size() - 1).setValue(freshValueClone);
}
}
freshValueClone.setParameters(newParams.isEmpty() ? null : newParams);
return freshValueClone;
}
@Override
public Metric getFullMetric(Long id) {
Metric metric = metricDAO.get(id);
if (metric == null) {
return null;
}
metric = metric.clone();
if (metric.getTests() != null) {
List<Test> clonedTests = metric.getTests().stream().collect(Collectors.toList());
metric.setTests(clonedTests);
}
return metric;
}
protected void sendRegularMetrics(final Long epoch) {
for (Entry<String, SortedMap<MetricName, Metric>> entry :
getMetricsRegistry().groupedMetrics(c.predicate).entrySet()) {
for (Entry<MetricName, Metric> subEntry : entry.getValue().entrySet()) {
final Metric metric = subEntry.getValue();
if (metric != null) {
try {
metric.processWith(this, subEntry.getKey(), epoch);
} catch (Exception ignored) {
LOG.error("Error sending regular metric:", ignored);
}
}
}
}
}
private <T> void checkNormalized(Iterable<T> targets, Metric<T> metric) {
for (T target1 : targets) {
for (T target2 : targets) {
if (target1 == target2) continue;
double distance1 = metric.distance(target1, target2);
assertTrue(">1", Double.compare(distance1, 1d) <= 0);
assertTrue("<0", Double.compare(distance1, 0d) >= 0);
double distance2 = metric.distance(target2, target1);
assertTrue(">1", Double.compare(distance2, 1d) <= 0);
assertTrue("<0", Double.compare(distance2, 0d) >= 0);
}
}
}
/**
* Creates a ClusteringFeature.
*
* @param center the center point
* @param radius the radius
*/
public ClusteringFeature(double[] center, double radius) {
super(center, radius, 1);
this.numPoints = 1;
this.sumPoints = new double[center.length];
System.arraycopy(center, 0, this.sumPoints, 0, center.length);
this.sumSquaredLength = Metric.distanceSquared(center);
}
/**
* Creates a measure with a metric and an alert level
*
* @param metric the metric
* @param level the alert level
*/
public Measure(Metric metric, Metric.Level level) {
this.metric = metric;
this.metricKey = metric.getKey();
if (level != null) {
this.data = level.toString();
}
}
@Override
public Metric deserialize(
JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext)
throws JsonParseException {
JsonObject jsonObject = jsonElement.getAsJsonObject();
String name = null;
if (jsonObject.get("name") != null) name = jsonObject.get("name").getAsString();
boolean exclude_tags = false;
if (jsonObject.get("exclude_tags") != null)
exclude_tags = jsonObject.get("exclude_tags").getAsBoolean();
TreeMultimap<String, String> tags = TreeMultimap.create();
JsonElement jeTags = jsonObject.get("tags");
if (jeTags != null) {
JsonObject joTags = jeTags.getAsJsonObject();
int count = 0;
for (Map.Entry<String, JsonElement> tagEntry : joTags.entrySet()) {
String context = "tags[" + count + "]";
if (tagEntry.getKey().isEmpty())
throw new ContextualJsonSyntaxException(context, "name must not be empty");
if (tagEntry.getValue().isJsonArray()) {
for (JsonElement element : tagEntry.getValue().getAsJsonArray()) {
if (element.isJsonNull() || element.getAsString().isEmpty())
throw new ContextualJsonSyntaxException(
context + "." + tagEntry.getKey(), "value must not be null or empty");
tags.put(tagEntry.getKey(), element.getAsString());
}
} else {
if (tagEntry.getValue().isJsonNull() || tagEntry.getValue().getAsString().isEmpty())
throw new ContextualJsonSyntaxException(
context + "." + tagEntry.getKey(), "value must not be null or empty");
tags.put(tagEntry.getKey(), tagEntry.getValue().getAsString());
}
count++;
}
}
Metric ret = new Metric(name, exclude_tags, tags);
JsonElement limit = jsonObject.get("limit");
if (limit != null) ret.setLimit(limit.getAsInt());
return (ret);
}
public void copy(String inSource, String inTarget) throws Exception {
// get arguments
URL source = URLFactory.createURL(inSource);
URL target = URLFactory.createURL(inTarget);
// execute command
Session session = SessionFactory.createSession(true);
NSEntry entry = NSFactory.createNSEntry(session, source, Flags.NONE.getValue());
Task task = entry.copy(TaskMode.TASK, target);
try {
Metric metric = task.getMetric("file.copy.progress");
metric.addCallback(
new Callback() {
public boolean cb(Monitorable mt, Metric metric, Context ctx)
throws NotImplementedException, AuthorizationFailedException {
try {
String value = metric.getAttribute(Metric.VALUE);
String unit = metric.getAttribute(Metric.UNIT);
System.out.println("Progress: " + value + " " + unit);
} catch (NotImplementedException e) {
throw e;
} catch (AuthorizationFailedException e) {
throw e;
} catch (Exception e) {
e.printStackTrace();
}
// callback must stay registered
return true;
}
});
} catch (DoesNotExistException e) {
System.err.println("WARN: Monitoring is not supported for this kind of transfer");
}
task.run();
task.waitFor();
switch (task.getState()) {
case DONE:
System.out.println("File successfully copied !");
break;
default:
task.rethrow();
break;
}
entry.close();
}
/**
* Sets the data field of the measure.
*
* @param s the data
* @return the measure object instance
*/
public Measure setData(String s) {
if (s != null && s.length() >= MAX_TEXT_SIZE && !metric.isDataType()) {
throw new IllegalArgumentException(
"Data is too long for non-data metric : size=" + s.length() + ", max=" + MAX_TEXT_SIZE);
}
this.data = s;
return this;
}
public void setMetric(Metric metric) {
if (metric == null) {
throw new DaoException(
"To-one property 'metric_id' has not-null constraint; cannot set to-one to null");
}
synchronized (this) {
this.metric = metric;
metric_id = metric.getId();
metric__resolvedKey = metric_id;
}
}
// --------------------------------------------------------------------------
public DataPoint setMetricRef(Metric table) {
// We add the record to the transaction if one of the key values change
if (m_metricId.setValue(table.getId())) {
if ((m_dirtyFlags.isEmpty()) && (GenOrmDataSource.getGenOrmConnection() != null))
GenOrmDataSource.getGenOrmConnection().addToTransaction(this);
m_dirtyFlags.set(METRIC_ID_FIELD_META.getDirtyFlag());
}
return ((DataPoint) this);
}
private <T> void checkSymmetric(Iterable<T> targets, Metric<T> metric) {
for (T target1 : targets) {
for (T target2 : targets) {
if (target1 == target2) continue;
double distance1 = metric.distance(target1, target2);
double distance2 = metric.distance(target2, target1);
assertTrue("not symmetric", Double.compare(distance1, distance2) == 0);
}
}
}
private void searchA(final int maxALength) {
stackA[0].length = 0;
stackA[0].turnIndex = 0;
int d = 0;
do {
while (stackA[d].length < maxALength) {
final ANode node = stackA[d];
if (node.turnIndex >= node.turns.length) {
if (--d < 0) return;
} else {
final Turn userTurn = node.turns[node.turnIndex++];
node.userTurn = userTurn;
final Turn cubeTurn = SymTransform.getTurn(userTurn, node.symmetry);
node.cubeTurn = cubeTurn;
final ANode nextNode = stackA[d + 1];
final int length = node.length + metric.length(cubeTurn);
if (length <= maxALength && length <= maxSearchLength) {
final int ct = transform.twistTable.turn(cubeTurn, node.twist);
final int ef = transform.flipTable.turn(cubeTurn, node.flip);
aprn++;
if (aprn % CYCLES_BETWEEN_USER_CHECK == 0 && (isInterrupted = reporter.shouldStop()))
return;
final int ct_ef_d = pruneA.get_twist_flip_dist(node.twist_flip_dist, ct, ef);
if (ct_ef_d <= maxALength - length) {
final int meps = transform.mEdgePosSetTable.turn(cubeTurn, node.mEdgePosSet);
final int ct_meps_d =
pruneA.get_twist_mEdgePosSet_dist(node.twist_mEdgePosSet_dist, ct, meps);
if (ct_meps_d <= maxALength - length) {
final int ef_meps_d =
pruneA.get_flip_mEdgePosSet_dist(node.flip_mEdgePosSet_dist, ef, meps);
if (ef_meps_d <= maxALength - length) {
final int ct_d = pruneA.get_twistFull_dist(node.twist_dist, ct);
final int ef_d = pruneA.get_flipFull_dist(node.flip_dist, ef);
if (ct_d <= maxALength - length && ef_d <= maxALength - length) {
nextNode.setCubeStateA(ct, ef, meps);
nextNode.setDists(ct_ef_d, ct_meps_d, ef_meps_d, ct_d, ef_d);
nextNode.setTurnState(node, userTurn, turnList);
nextNode.length = length;
d++;
} else apry++;
} else apry++;
} else apry++;
} else apry++;
}
}
}
stackASize = d--;
solveB(maxALength);
} while (!isInterrupted && d >= 0);
}
public MetricRepositoryRule add(Metric metric) {
requireNonNull(metric.getKey(), "key can not be null");
requireNonNull(metric.getId(), "id can not be null");
checkState(
!metricsByKey.containsKey(metric.getKey()),
format("Repository already contains a metric for key %s", metric.getKey()));
checkState(
!metricsById.containsKey((long) metric.getId()),
format("Repository already contains a metric for id %s", metric.getId()));
metricsByKey.put(metric.getKey(), metric);
metricsById.put((long) metric.getId(), metric);
return this;
}
public List<Metric> reportFindings() {
swapCaches();
Map<String, List<MetricDataPoint>> cache = getInActiveCache();
Set<String> keys = cache.keySet();
List<Metric> metrics = new ArrayList<Metric>();
for (String key : keys) {
List<MetricDataPoint> dps = cache.get(key);
int max = 0;
int min = 10000000;
int counter = 0;
long total = 0;
long executionTime;
double average = 0;
for (MetricDataPoint dp : dps) {
counter++;
executionTime = dp.getExecutionTime();
if (executionTime < min) min = (int) executionTime;
if (executionTime > max) max = (int) executionTime;
total += executionTime;
}
if (counter > 0) average = total / counter;
Metric metric = new Metric();
metric.setKey(key);
metric.setMax(max);
metric.setMin(min);
metric.setAverage(average);
metrics.add(metric);
}
return metrics;
}
private void searchB(final int maxALength, final int maxBLength) {
stackB[0].length = 0;
stackB[0].turnIndex = 0;
int d = 0;
do {
while (stackB[d].length < maxBLength) {
final BNode node = stackB[d];
if (node.turnIndex >= node.turns.length) {
if (--d < 0) return;
} else {
final Turn userTurn = node.turns[node.turnIndex++];
node.userTurn = userTurn;
final Turn cubeTurn = SymTransform.getTurn(userTurn, node.symmetry);
node.cubeTurn = cubeTurn;
final int length = node.length + metric.length(userTurn);
if (cubeTurn.isB() && maxALength + length <= maxSearchLength && length <= maxBLength) {
final BNode nextNode = stackB[d + 1];
final int mep = transformB.mEdgePosTable.turn(cubeTurn, node.mEdgePos);
final int cp = transformB.cornerPosTable.turn(cubeTurn, node.cornerPos);
bprn++;
if (bprn % CYCLES_BETWEEN_USER_CHECK == 0 && (isInterrupted = reporter.shouldStop()))
return;
final int mep_cp_d =
pruneB.get_mEdgePos_cornerPos_dist(node.mEdgePos_cornerPos_dist, mep, cp);
if (mep_cp_d <= maxBLength - length) {
final int udep = transformB.udEdgePosTable.turn(cubeTurn, node.udEdgePos);
final int mep_udep_d =
pruneB.get_mEdgePos_udEdgePos_dist(node.mEdgePos_udEdgePos_dist, mep, udep);
if (mep_udep_d <= maxBLength - length) {
nextNode.setCubeState(mep, cp, udep);
nextNode.setDists(mep_cp_d, mep_udep_d);
nextNode.setTurnState(node, userTurn, turnListB);
nextNode.length = length;
d++;
} else bpry++;
} else bpry++;
}
}
}
stackBSize = d--;
display();
maxSearchLength = maxALength + maxBLength - (findAll ? 0 : 1);
} while (!isInterrupted && d >= 0);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (obj instanceof Metric == false) return false;
Metric other = (Metric) obj;
if (other.getNamespace() == null ^ this.getNamespace() == null) return false;
if (other.getNamespace() != null && other.getNamespace().equals(this.getNamespace()) == false)
return false;
if (other.getMetricName() == null ^ this.getMetricName() == null) return false;
if (other.getMetricName() != null
&& other.getMetricName().equals(this.getMetricName()) == false) return false;
if (other.getDimensions() == null ^ this.getDimensions() == null) return false;
if (other.getDimensions() != null
&& other.getDimensions().equals(this.getDimensions()) == false) return false;
return true;
}
private void logMetrics() {
for (Metric m : metrics.values()) log.info(m.toString());
}
private List<QueryMetric> parseQueryMetric(JsonObject obj, String contextPrefix)
throws QueryException, BeanValidationException {
List<QueryMetric> ret = new ArrayList<QueryMetric>();
Query query;
try {
query = m_gson.fromJson(obj, Query.class);
validateObject(query);
} catch (ContextualJsonSyntaxException e) {
throw new BeanValidationException(
new SimpleConstraintViolation(e.getContext(), e.getMessage()), "query");
}
JsonArray metricsArray = obj.getAsJsonArray("metrics");
if (metricsArray == null) {
throw new BeanValidationException(
new SimpleConstraintViolation("metric[]", "must have a size of at least 1"),
contextPrefix + "query");
}
for (int I = 0; I < metricsArray.size(); I++) {
String context =
(!contextPrefix.isEmpty() ? contextPrefix + "." : contextPrefix)
+ "query.metric["
+ I
+ "]";
try {
Metric metric = m_gson.fromJson(metricsArray.get(I), Metric.class);
validateObject(metric, context);
long startTime = getStartTime(query, context);
QueryMetric queryMetric =
new QueryMetric(startTime, query.getCacheTime(), metric.getName());
queryMetric.setExcludeTags(metric.isExcludeTags());
queryMetric.setLimit(metric.getLimit());
long endTime = getEndTime(query);
if (endTime > -1) queryMetric.setEndTime(endTime);
if (queryMetric.getEndTime() < startTime)
throw new BeanValidationException(
new SimpleConstraintViolation("end_time", "must be greater than the start time"),
context);
queryMetric.setCacheString(query.getCacheString() + metric.getCacheString());
JsonObject jsMetric = metricsArray.get(I).getAsJsonObject();
JsonElement group_by = jsMetric.get("group_by");
if (group_by != null) {
JsonArray groupBys = group_by.getAsJsonArray();
parseGroupBy(context, queryMetric, groupBys);
}
JsonElement aggregators = jsMetric.get("aggregators");
if (aggregators != null) {
JsonArray asJsonArray = aggregators.getAsJsonArray();
if (asJsonArray.size() > 0)
parseAggregators(context, queryMetric, asJsonArray, query.getTimeZone());
}
JsonElement plugins = jsMetric.get("plugins");
if (plugins != null) {
JsonArray pluginArray = plugins.getAsJsonArray();
if (pluginArray.size() > 0) parsePlugins(context, queryMetric, pluginArray);
}
JsonElement order = jsMetric.get("order");
if (order != null) queryMetric.setOrder(Order.fromString(order.getAsString(), context));
queryMetric.setTags(metric.getTags());
ret.add(queryMetric);
} catch (ContextualJsonSyntaxException e) {
throw new BeanValidationException(
new SimpleConstraintViolation(e.getContext(), e.getMessage()), context);
}
}
return (ret);
}
/**
* Calculates the k-means costs of the ClusteringFeature too a center.
*
* @param center the center too calculate the costs
* @return the costs
*/
public double calcKMeansCosts(double[] center) {
assert (this.sumPoints.length == center.length);
return this.sumSquaredLength
- 2 * Metric.dotProduct(this.sumPoints, center)
+ this.numPoints * Metric.dotProduct(center);
}
/**
* Calculates the k-means costs of the ClusteringFeature and a point too a center.
*
* @param center the center too calculate the costs
* @param point the point too calculate the costs
* @return the costs
*/
public double calcKMeansCosts(double[] center, double[] point) {
assert (this.sumPoints.length == center.length && this.sumPoints.length == point.length);
return (this.sumSquaredLength + Metric.distanceSquared(point))
- 2 * Metric.dotProductWithAddition(this.sumPoints, point, center)
+ (this.numPoints + 1) * Metric.dotProduct(center);
}
