List of usage examples for org.apache.hadoop.metrics2 MetricsRecord name
String name();
From source file:com.chocolatefactory.newrelic.plugins.hadoop.NewRelicSink.java
@Override public void putMetrics(MetricsRecord record) { HashMap<String, Float> summaryMetrics = new HashMap<String, Float>(); // Create new one for each record Request request = new Request(context); for (MetricsTag tag : record.tags()) { if ((tag.value() == null) || tag.value().isEmpty()) continue; else if (useInsights) insightsMetrics.put(tag.name().toLowerCase(), tag.value()); }/*from ww w . ja va 2s.co m*/ for (AbstractMetric metric : record.metrics()) { if ((metric.value() == null) || (metric.name() == null) || metric.name().isEmpty() || metric.value().toString().isEmpty()) { // NOT skipping "imax" and "imin" metrics, though they are constant and rather large // || metric.name().contains("_imin_") || metric.name().contains("_imax_")) { continue; } String metricName, metricType; String metricHashCode = record.context() + "_" + metric.name(); Float metricValue = metric.value().floatValue(); if (metricNames.containsKey(metricHashCode)) { metricName = metricNames.get(metricHashCode)[0]; metricType = metricNames.get(metricHashCode)[1]; } else { metricName = getMetricName(metric); metricType = getMetricType(metric); metricNames.put(metricHashCode, new String[] { metricName, metricType }); // Get groupings for new metrics only if (debugEnabled && getGroupings) { addMetricGroup(getMetricBaseName(record, categoryName), metricType); addMetricGroup(getMetricBaseName(record, categoryName + div + deltaName), metricType); } } if (useInsights) { insightsMetrics.put(metricName, metricValue); } // Debug // logger.info("metric name: " + metricName); // logger.info("metric type: " + metricType); // logger.info("metric value: " + metricValue); // logger.info("metric hashcode: " + metricHashCode); // If old metric value exists, use it to compute delta. If not, delta is metric value. // In any case, set oldValue to use for next delta. Float oldMetricValue = (float) 0; if (oldMetricValues.containsKey(metricHashCode)) { oldMetricValue = oldMetricValues.get(metricHashCode); // logger.info("metric OLD value: " + oldMetricValue); } Float deltaMetricValue = metricValue - oldMetricValue; // logger.info("delta value: " + deltaMetricValue); if (deltaMetricValue < 0.0) { // logger.info("delta is less than 0"); deltaMetricValue = (float) 0; } if (metricValue > 0) { oldMetricValues.put(metricHashCode + "", metricValue); // logger.info("putting value to OLD: " + metricValue); } addMetric(request, getMetricBaseName(record, categoryName) + div + metricName, metric.name(), metricType, metricValue); addMetric(request, getMetricBaseName(record, categoryName + div + deltaName) + div + metricName, metric.name(), metricType, deltaMetricValue); // If this is a metric to be included in summary metrics... include it! if (record.name().equalsIgnoreCase(hadoopProcType) && NewRelicMetrics.HadoopOverviewMetrics.contains(metricType)) { if (!summaryMetrics.containsKey(metricType)) { summaryMetrics.put(metricType, deltaMetricValue); // logger.info("putting NEW summary metric: " + deltaMetricValue); } else { Float newValue = summaryMetrics.get(metricType) + deltaMetricValue; summaryMetrics.put(metricType, newValue); // logger.info("putting UPDATED summary metric: " + newValue); } // Summary metrics are also included in the 2 top graphs in the "Overview" dashboard addMetric(request, getMetricBaseName(record, categoryName + div + overviewName) + div + metricName, metric.name(), metricType, metricValue); addMetric(request, getMetricBaseName(record, categoryName + div + overviewName + "_" + deltaName) + div + metricName, metric.name(), metricType, deltaMetricValue); } } // Get summary metrics, reset each one after output. if (!summaryMetrics.isEmpty()) { for (Entry<String, Float> summaryMetric : summaryMetrics.entrySet()) { addMetric(request, categoryName + div + overviewName + div + "total " + summaryMetric.getKey(), summaryMetric.getKey(), summaryMetric.getKey(), summaryMetric.getValue()); } } if (debugEnabled) { logger.info("Debug is enabled on New Relic Hadoop Extension. Metrics will not be sent."); if (getGroupings) { logger.info("Outputting metric groupings from the current Metrics Record."); for (Map.Entry<String, Integer> grouping : metricGroupings.entrySet()) { logger.info(grouping.getKey() + " : " + grouping.getValue()); } } } else { request.deliver(); if (useInsights) { insightsService.submitToInsights(hadoopProcType + "Event", insightsMetrics); } } }
From source file:com.chocolatefactory.newrelic.plugins.hadoop.NewRelicSink.java
public String getMetricBaseName(MetricsRecord record, String metricPrefix) { String metricBaseName = ""; if (!metricPrefix.isEmpty()) metricBaseName = metricPrefix + div + record.context(); else/* ww w . jav a 2 s.c om*/ metricBaseName = record.context(); if (!record.context().equalsIgnoreCase(record.name()) && !record.name().isEmpty()) metricBaseName = metricBaseName + div + record.name(); return metricBaseName; }
From source file:org.apache.phoenix.metrics.LoggingSink.java
License:Apache License
@Override public void putMetrics(MetricsRecord record) { // we could wait until flush, but this is a really lightweight process, so we just write // them/*from ww w. ja v a 2 s .co m*/ // as soon as we get them if (!LOG.isDebugEnabled()) { return; } LOG.debug("Found record:" + record.name()); for (AbstractMetric metric : record.metrics()) { // just print the metric we care about if (metric.name().startsWith(TracingUtils.METRIC_SOURCE_KEY)) { LOG.debug("\t metric:" + metric); } } }
From source file:org.apache.phoenix.monitoring.GlobalPhoenixMetricsTestSink.java
License:Apache License
@Override public void putMetrics(MetricsRecord metricsRecord) { if (metricsRecord.name().equals(PHOENIX_METRICS_RECORD_NAME)) { synchronized (GlobalPhoenixMetricsTestSink.lock) { GlobalPhoenixMetricsTestSink.metrics = metricsRecord.metrics(); }/* www .j av a 2 s . c o m*/ } }
From source file:org.apache.phoenix.trace.PhoenixMetricsSink.java
License:Apache License
/** * Add a new metric record to be written. * * @param record/* www. ja va 2 s. c o m*/ */ @Override public void putMetrics(MetricsRecord record) { // its not a tracing record, we are done. This could also be handled by filters, but safer // to do it here, in case it gets misconfigured if (!record.name().startsWith(TracingUtils.METRIC_SOURCE_KEY)) { return; } // don't initialize until we actually have something to write lazyInitialize(); String stmt = "UPSERT INTO " + table + " ("; // drop it into the queue of things that should be written List<String> keys = new ArrayList<String>(); List<Object> values = new ArrayList<Object>(); // we need to keep variable values in a separate set since they may have spaces, which // causes the parser to barf. Instead, we need to add them after the statement is prepared List<String> variableValues = new ArrayList<String>(record.tags().size()); keys.add(TRACE.columnName); values.add(Long.parseLong(record.name().substring(TracingUtils.METRIC_SOURCE_KEY.length()))); keys.add(DESCRIPTION.columnName); values.add(VARIABLE_VALUE); variableValues.add(record.description()); // add each of the metrics for (AbstractMetric metric : record.metrics()) { // name of the metric is also the column name to which we write keys.add(MetricInfo.getColumnName(metric.name())); values.add(metric.value()); } // get the tags out so we can set them later (otherwise, need to be a single value) int annotationCount = 0; int tagCount = 0; for (MetricsTag tag : record.tags()) { if (tag.name().equals(ANNOTATION.traceName)) { addDynamicEntry(keys, values, variableValues, ANNOTATION_FAMILY, tag, ANNOTATION, annotationCount); annotationCount++; } else if (tag.name().equals(TAG.traceName)) { addDynamicEntry(keys, values, variableValues, TAG_FAMILY, tag, TAG, tagCount); tagCount++; } else if (tag.name().equals(HOSTNAME.traceName)) { keys.add(HOSTNAME.columnName); values.add(VARIABLE_VALUE); variableValues.add(tag.value()); } else if (tag.name().equals("Context")) { // ignored } else { LOG.error("Got an unexpected tag: " + tag); } } // add the tag count, now that we know it keys.add(TAG_COUNT); // ignore the hostname in the tags, if we know it values.add(tagCount); keys.add(ANNOTATION_COUNT); values.add(annotationCount); // compile the statement together stmt += COMMAS.join(keys); stmt += ") VALUES (" + COMMAS.join(values) + ")"; if (LOG.isTraceEnabled()) { LOG.trace("Logging metrics to phoenix table via: " + stmt); LOG.trace("With tags: " + variableValues); } try { PreparedStatement ps = conn.prepareStatement(stmt); // add everything that wouldn't/may not parse int index = 1; for (String tag : variableValues) { ps.setString(index++, tag); } // Not going through the standard route of using statement.execute() as that code path // is blocked if the metadata hasn't been been upgraded to the new minor release. MutationPlan plan = ps.unwrap(PhoenixPreparedStatement.class).compileMutation(stmt); MutationState state = conn.unwrap(PhoenixConnection.class).getMutationState(); MutationState newState = plan.execute(); state.join(newState); } catch (SQLException e) { LOG.error("Could not write metric: \n" + record + " to prepared statement:\n" + stmt, e); } }
From source file:org.apache.phoenix.trace.PhoenixMetricsWriterTest.java
License:Apache License
@Test public void testTranslation() throws Exception { // hook up a sink we can test MetricsWriter mockSink = Mockito.mock(MetricsWriter.class); // writer that will translate to the sink (specific to hadoop version used) PhoenixMetricsSink writer = new PhoenixMetricsSink(); writer.setWriterForTesting(mockSink); // create a simple metrics record final long traceid = 987654; MetricsInfo info = new ExposedMetricsInfoImpl(TracingCompat.getTraceMetricName(traceid), "Some generic trace"); // setup some metrics for the span long spanid = 10; AbstractMetric span = new ExposedMetricCounterLong( new ExposedMetricsInfoImpl(MetricInfo.SPAN.traceName, ""), spanid); long parentid = 11; AbstractMetric parent = new ExposedMetricCounterLong( new ExposedMetricsInfoImpl(MetricInfo.PARENT.traceName, ""), parentid); long startTime = 12; AbstractMetric start = new ExposedMetricCounterLong( new ExposedMetricsInfoImpl(MetricInfo.START.traceName, ""), startTime); long endTime = 13; AbstractMetric end = new ExposedMetricCounterLong(new ExposedMetricsInfoImpl(MetricInfo.END.traceName, ""), endTime);//from w ww .ja v a 2s.c om final List<AbstractMetric> metrics = Lists.newArrayList(span, parent, start, end); // create an annotation as well String annotation = "test annotation for a span"; MetricsTag tag = new MetricsTag(new ExposedMetricsInfoImpl(MetricInfo.ANNOTATION.traceName, "0"), annotation); String hostnameValue = "host-name.value"; MetricsTag hostname = new MetricsTag(new ExposedMetricsInfoImpl(MetricInfo.HOSTNAME.traceName, ""), hostnameValue); final List<MetricsTag> tags = Lists.newArrayList(hostname, tag); MetricsRecord record = new ExposedMetricsRecordImpl(info, System.currentTimeMillis(), tags, metrics); // setup the mocking/validation for the sink Mockito.doAnswer(new Answer<Void>() { @Override public Void answer(InvocationOnMock invocation) throws Throwable { PhoenixMetricsRecord record = (PhoenixMetricsRecord) invocation.getArguments()[0]; //validate that we got the right fields in the record assertEquals("phoenix.987654", record.name()); assertEquals("Some generic trace", record.description()); int count = 0; for (PhoenixAbstractMetric metric : record.metrics()) { count++; //find the matching metric in the list boolean found = false; for (AbstractMetric expected : metrics) { if (expected.name().equals(metric.getName())) { found = true; // make sure the rest of the info matches assertEquals("Metric value mismatch", expected.value(), metric.value()); } } assertTrue("Didn't find an expected metric to match " + metric, found); } assertEquals("Number of metrics is received is wrong", metrics.size(), count); count = 0; for (PhoenixMetricTag tag : record.tags()) { count++; // find the matching metric in the list boolean found = false; for (MetricsTag expected : tags) { if (expected.name().equals(tag.name())) { found = true; // make sure the rest of the info matches assertEquals("Tag value mismatch", expected.value(), tag.value()); assertEquals("Tag description mismatch", expected.description(), tag.description()); } } assertTrue("Didn't find an expected metric to match " + tag, found); } assertEquals("Number of tags is received is wrong", tags.size(), count); return null; } }).when(mockSink).addMetrics(Mockito.any(PhoenixMetricsRecord.class)); // actually do the update writer.putMetrics(record); writer.flush(); Mockito.verify(mockSink).addMetrics(Mockito.any(PhoenixMetricsRecord.class)); Mockito.verify(mockSink).flush(); }