How to use

meter

method

in

com.codahale.metrics.MetricRegistry

public DropwizardRowIngestionMeters()
{
 this.metricRegistry = new MetricRegistry();
 this.processed = metricRegistry.meter(PROCESSED);
 this.processedWithError = metricRegistry.meter(PROCESSED_WITH_ERROR);
 this.unparseable = metricRegistry.meter(UNPARSEABLE);
 this.thrownAway = metricRegistry.meter(THROWN_AWAY);
}

public NetflowMessageAggregationHandler(RemoteAddressCodecAggregator aggregator, MetricRegistry metricRegistry) {
  this.aggregator = aggregator;
  aggregationTimer = metricRegistry.timer("aggregationTime");
  invalidChunksMeter = metricRegistry.meter("invalidMessages");
}

public ByteBufMessageAggregationHandler(CodecAggregator aggregator, MetricRegistry metricRegistry) {
  this.aggregator = aggregator;
  aggregationTimer = metricRegistry.timer("aggregationTime");
  invalidChunksMeter = metricRegistry.meter("invalidMessages");
}

public EnvelopeMessageAggregationHandler(CodecAggregator aggregator, MetricRegistry metricRegistry) {
  this.aggregator = aggregator;
  aggregationTimer = metricRegistry.timer("aggregationTime");
  invalidChunksMeter = metricRegistry.meter("invalidMessages");
}

@Inject
public ElasticSearchOutput(MetricRegistry metricRegistry,
              Messages messages,
              Journal journal) {
  this.messages = messages;
  this.journal = journal;
  // Only constructing metrics here. write() get's another Core reference. (because this technically is a plugin)
  this.writes = metricRegistry.meter(WRITES_METRICNAME);
  this.failures = metricRegistry.meter(FAILURES_METRICNAME);
  this.processTime = metricRegistry.timer(PROCESS_TIME_METRICNAME);
  // Should be set in initialize once this becomes a real plugin.
  isRunning.set(true);
}

private Meter getIncomingMeter(String streamId) {
  Meter meter = this.streamIncomingMeters.get(streamId);
  if (meter == null) {
    meter = metricRegistry.meter(MetricRegistry.name(Stream.class, streamId, "incomingMessages"));
    this.streamIncomingMeters.put(streamId, meter);
  }
  return meter;
}

private Meter getStreamRuleTimeoutMeter(final String streamId) {
  Meter meter = this.streamRuleTimeoutMeters.get(streamId);
  if (meter == null) {
    meter = metricRegistry.meter(MetricRegistry.name(Stream.class, streamId, "ruleTimeouts"));
    this.streamRuleTimeoutMeters.put(streamId, meter);
  }
  return meter;
}

private Meter getExceptionMeter(String streamId) {
  Meter meter = this.streamExceptionMeters.get(streamId);
  if (meter == null) {
    meter = metricRegistry.meter(MetricRegistry.name(Stream.class, streamId, "matchingExceptions"));
    this.streamExceptionMeters.put(streamId, meter);
  }
  return meter;
}

  private Meter getStreamFaultsExceededMeter(final String streamId) {
    Meter meter = this.streamFaultsExceededMeters.get(streamId);
    if (meter == null) {
      meter = metricRegistry.meter(MetricRegistry.name(Stream.class, streamId, "faultsExceeded"));
      this.streamFaultsExceededMeters.put(streamId, meter);
    }

    return meter;
  }
}

@Inject
public DiscardMessageOutput(final Journal journal, final MetricRegistry metricRegistry) {
  this.journal = journal;
  this.messagesDiscarded = metricRegistry.meter(name(this.getClass(), "messagesDiscarded"));
  isRunning.set(true);
}

@Inject
public PipelineInterpreter(Journal journal,
              MetricRegistry metricRegistry,
              ConfigurationStateUpdater stateUpdater) {
  this.journal = journal;
  this.filteredOutMessages = metricRegistry.meter(name(ProcessBufferProcessor.class, "filteredOutMessages"));
  this.executionTime = metricRegistry.timer(name(PipelineInterpreter.class, "executionTime"));
  this.stateUpdater = stateUpdater;
}

@Inject
public Messages(MetricRegistry metricRegistry,
        JestClient client) {
  invalidTimestampMeter = metricRegistry.meter(name(Messages.class, "invalid-timestamps"));
  outputByteCounter = metricRegistry.counter(GlobalMetricNames.OUTPUT_TRAFFIC);
  systemTrafficCounter = metricRegistry.counter(GlobalMetricNames.SYSTEM_OUTPUT_TRAFFIC);
  this.client = client;
  // TODO: Magic number
  this.indexFailureQueue =  new LinkedBlockingQueue<>(1000);
}

/**
 * Register the metrics attached to this stage.
 *
 * @param metricRegistry the registry to add the metrics to
 */
public void registerMetrics(MetricRegistry metricRegistry, String pipelineId) {
  meterName = name(Pipeline.class, pipelineId, "stage", String.valueOf(stage()), "executed");
  executed = metricRegistry.meter(meterName);
}

private Meter registerLocalMeter(MetricRegistry metricRegistry,
                 String pipelineId,
                 String stageId, String type) {
  final String name = MetricRegistry.name(Rule.class, id(), pipelineId, stageId, type);
  metricNames.add(name);
  return metricRegistry.meter(name);
}

@AssistedInject
public ProcessBufferProcessor(MetricRegistry metricRegistry, OrderedMessageProcessors orderedMessageProcessors, OutputBuffer outputBuffer,
               @Assisted DecodingProcessor decodingProcessor, @DefaultStream Provider<Stream> defaultStreamProvider) {
  this.orderedMessageProcessors = orderedMessageProcessors;
  this.outputBuffer = outputBuffer;
  this.decodingProcessor = decodingProcessor;
  this.defaultStreamProvider = defaultStreamProvider;
  incomingMessages = metricRegistry.meter(name(ProcessBufferProcessor.class, "incomingMessages"));
  outgoingMessages = metricRegistry.meter(name(ProcessBufferProcessor.class, "outgoingMessages"));
  processTime = metricRegistry.timer(name(ProcessBufferProcessor.class, "processTime"));
}

private Meter registerGlobalMeter(MetricRegistry metricRegistry, String type) {
  final String name = MetricRegistry.name(Rule.class, id(), type);
  metricNames.add(name);
  return metricRegistry.meter(name);
}

/**
 * Register the metrics attached to this pipeline.
 *
 * @param metricRegistry the registry to add the metrics to
 */
public void registerMetrics(MetricRegistry metricRegistry) {
  if (id() != null) {
    metricName = MetricRegistry.name(Pipeline.class, id(), "executed");
    executed = metricRegistry.meter(metricName);
  }
}

public static Meter meter(String name, WorkerTopologyContext context, String componentId, Integer taskId, String streamId) {
  String metricName = metricName(name, context.getStormId(), componentId, streamId, taskId, context.getThisWorkerPort());
  return REGISTRY.meter(metricName);
}

public MeteredMetricsFilter(MetricRegistry metricRegistry, ResourceInfo resourceInfo) {
  final Metered annotation = resourceInfo.getResourceMethod().getAnnotation(Metered.class);
  meter = metricRegistry.meter(chooseName(annotation.name(), annotation.absolute(), resourceInfo.getResourceMethod()));
}
@Override

public ExceptionMeteredMetricsFilter(MetricRegistry metricRegistry, ResourceInfo resourceInfo) {
  final ExceptionMetered annotation = resourceInfo.getResourceMethod().getAnnotation(ExceptionMetered.class);
  meter = metricRegistry.meter(chooseName(annotation.name(), annotation.absolute(), resourceInfo.getResourceMethod(), ExceptionMetered.DEFAULT_NAME_SUFFIX));
  exceptionClass = annotation.cause();
}