import com.codahale.metrics.Timer; //导入依赖的package包/类
TrainingFetcher(MetricSampler metricSampler,
                Cluster cluster,
                SampleStore sampleStore,
                Set<TopicPartition> assignedPartitions,
                long startTimeMs,
                long endTimeMs,
                Timer fetcherTimer,
                Meter fetcherFailureRate) {
  _cluster = cluster;
  _sampleStore = sampleStore;
  _metricSampler = metricSampler;
  _startTimeMs = startTimeMs;
  _endTimeMs = endTimeMs;
  _assignedPartitions = assignedPartitions;
  _fetcherTimer = fetcherTimer;
  _fetcherFailureRate = fetcherFailureRate;
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
@Override
protected void fetchMetricsForAssignedPartitions() throws MetricSamplingException {
  final Timer.Context ctx = _fetcherTimer.time();

  try {
    MetricSampler.Samples samples =
        _metricSampler.getSamples(_cluster, _assignedPartitions, _startTimeMs, _endTimeMs, MetricSampler.SamplingMode.BROKER_METRICS_ONLY);
    ModelParameters.addMetricObservation(samples.brokerMetricSamples());

    _sampleStore.storeSamples(samples);
  } catch (Exception e) {
    _fetcherFailureRate.mark();
    throw e;
  } finally {
    ctx.stop();
  }
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
/**
 * Create a new {@code ChangeLoader}.
 *
 * @param cxt the Bireme Context
 * @param pipeLine the {@code PipeLine} belongs to
 * @param mappedTable the target table
 * @param taskIn a queue to get {@code LoadTask}
 */
public ChangeLoader(Context cxt, PipeLine pipeLine, String mappedTable,
    LinkedBlockingQueue<Future<LoadTask>> taskIn) {
  this.cxt = cxt;
  this.conf = cxt.conf;
  this.conn = null;
  this.mappedTable = mappedTable;
  this.table = cxt.tablesInfo.get(mappedTable);
  this.taskIn = taskIn;
  this.copyThread = Executors.newFixedThreadPool(1);

  // add statistics
  Timer[] timers = pipeLine.stat.addTimerForLoader(mappedTable);
  copyForDeleteTimer = timers[0];
  deleteTimer = timers[1];
  copyForInsertTimer = timers[2];

  logger = pipeLine.logger;
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public MatchingServiceHealthCheckResponseDto sendHealthCheckRequest(
        final Element matchingServiceHealthCheckRequest,
        final URI matchingServiceUri) {

    // Use a custom timer so that we get separate metrics for each matching service
    final String scope = matchingServiceUri.toString().replace(':','_').replace('/', '_');
    final Timer timer = metricsRegistry.timer(MetricRegistry.name(MatchingServiceHealthCheckClient.class, "sendHealthCheckRequest", scope));
    final Timer.Context context = timer.time();
    HealthCheckResponse healthCheckResponse;
    try {
        healthCheckResponse = client.makeSoapRequestForHealthCheck(matchingServiceHealthCheckRequest, matchingServiceUri);
    } catch(ApplicationException ex) {
        final String errorMessage = MessageFormat.format("Failed to complete matching service health check to {0}.", matchingServiceUri);
        LOG.warn(errorMessage, ex);
        return new MatchingServiceHealthCheckResponseDto(Optional.<String>absent(), Optional.<String>absent());
    } finally {
        context.stop();
    }

    return new MatchingServiceHealthCheckResponseDto(
                Optional.of(XmlUtils.writeToString(healthCheckResponse.getResponseElement())),
                healthCheckResponse.getVersionNumber());
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
    Bench<JedisPool> bench = new JedisBench() {
        @Override
        public void executeOperation(String data, JedisPool benchInstance, int threadNumber, int iteration,
                MetricRegistry metrics) {
            Jedis jedis = benchInstance.getResource();
            
            Timer.Context time = metrics.timer("incr").time();
            jedis.incr("incr_" + threadNumber + "_" + iteration);
            time.stop();
            
            jedis.close();
        }
    };
    
    Benchmark benchmark = new Benchmark(bench);
    benchmark.run(args);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
private void removeGraphRelation(
    Group group,
    String relation,
    String subjectType,
    String subjectKey,
    String objectType,
    String objectKey,
    Timer timer
) {
  final String rel = REL_MARK;
  final String inv = INV_MARK;

  final String relationHashKey = subjectType + "." + subjectKey;
  final String relationRangeKey = rel + relation + "." + objectType + "." + objectKey;
  timed(timer,
      () -> groupStorage.removeRelation(group, relationHashKey, relationRangeKey));

  final String inverseRelationHashKey = objectType + "." + objectKey;
  final String inverseRelationRangeKey = inv + relation + "." + subjectType + "." + subjectKey;
  timed(timer,
      () -> groupStorage.removeRelation(group, inverseRelationHashKey, inverseRelationRangeKey));
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {

    EnableMetricTimer annotation = methodInvocation.getThis().getClass().getAnnotation(EnableMetricTimer.class);

    String name = StringUtils.isBlank(annotation.value())
            ? methodInvocation.getThis().getClass().getName() + "." + methodInvocation.getMethod().getName()
            : annotation.value();

    Timer meter = Jboot.me().getMetric().timer(name);
    Timer.Context timerContext = meter.time();
    try {
        return methodInvocation.proceed();
    } finally {
        timerContext.stop();
    }

}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
    Bench<JedisPool> bench = new JedisBench() {
        @Override
        public void executeOperation(String data, JedisPool benchInstance, int threadNumber, int iteration,
                MetricRegistry metrics) {
            Jedis jedis = benchInstance.getResource();

            Timer.Context time = metrics.timer("set").time();
            String key = "set_" + threadNumber;
            jedis.sadd(key, data);
            time.stop();

            jedis.close();
        }
    };
    
    Benchmark benchmark = new Benchmark(bench);
    benchmark.run(args);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
    Bench<JedisPool> bench = new JedisBench() {
        @Override
        public void executeOperation(String data, JedisPool benchInstance, int threadNumber, int iteration,
                MetricRegistry metrics) {
            Jedis jedis = benchInstance.getResource();

            Timer.Context time = metrics.timer("list").time();
            String key = "list_" + threadNumber;
            jedis.rpush(key, data);
            time.stop();

            jedis.close();
        }
    };
    
    Benchmark benchmark = new Benchmark(bench);
    benchmark.run(args);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
@Test
public void rxJava() throws Exception {
    CountDownLatch latch = new CountDownLatch(1);

    RxJavaClient client = retrofit.create(RxJavaClient.class);
    client.timed()
            .subscribe(response -> {
                try {
                    assertThat(response.code()).isEqualTo(HttpURLConnection.HTTP_OK);
                    assertThat(response.body()).isEqualTo(RESPONSE_OBJECT);
                } finally {
                    latch.countDown();
                }
            }, error -> {
                throw new RuntimeException("Test failed");
            });
    latch.await(1L, TimeUnit.SECONDS);

    Timer timer = metrics.timer(TIMER_NAME);
    assertThat(timer).isNotNull();
    assertThat(timer.getCount()).isEqualTo(1);
    assertThat(timer.getMeanRate()).isGreaterThan(0);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
private void adjustRateLimit() {
    final long count = acquireCount.incrementAndGet();
    if (count >= pollOnCount) {
        final Timer commitTimer = actorContext.getOperationTimer(ActorContext.COMMIT);
        double newRateLimit = calculateNewRateLimit(commitTimer, commitTimeoutInSeconds);

        if (newRateLimit < 1.0) {
            newRateLimit = getRateLimitFromOtherDataStores();
        }

        if (newRateLimit >= 1.0) {
            txRateLimiter.setRate(newRateLimit);
            pollOnCount = count + (long) newRateLimit / 2;
        }
    }
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
@Before
public void setup() throws RpcCallException {
    handlerDictionary = new MethodHandlerDictionary();
    handlerDictionary.put("a", null);
    ServiceMethodHandlerUnderTest mockHandlerThrowsRpcCallEx = new ServiceMethodHandlerUnderTest();

    handlerDictionary.put("jsonRpcWithException", mockHandlerThrowsRpcCallEx);

    metricRegistry = mock(MetricRegistry.class);
    when(metricRegistry.counter(anyString())).thenReturn(mock(Counter.class));
    when(metricRegistry.timer(anyString())).thenReturn(mock(Timer.class));

    handlerMetrics = mock(RpcHandlerMetrics.class);
    when(handlerMetrics.getMethodTimer(any(), any(), any())).thenReturn(mock(GoTimer.class));

    servlet = new JsonHandler(handlerDictionary, metricRegistry, handlerMetrics, new ServiceProperties(), null);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
private void assertMetrics() {
    Timer timer = metricRegistry.getTimers().values().iterator().next();
    assertEquals("wrong number of invocations in metric.", 1, timer.getCount());

    assertTrue("wrong value of mean in metric.", timer.getMeanRate() > 0);

    assertEquals("wrong number of meter metrics.", 2, metricRegistry.getMeters().values().size());

    Set<Map.Entry<String, Meter>> entries = metricRegistry.getMeters().entrySet();

    entries.forEach(entry -> {
        if (entry.getKey().endsWith("Metered")) {
            assertEquals(String.format("wrong number of invocations in metric %s", entry.getKey()), 1,
                    entry.getValue().getCount());
        }
    });

}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public void onCallbackComplete(Operation operation) {
  Long startTime = removeObjectProperty(operation, OPERATION_PROPERTY_NAME);
  if (startTime == null) {
    return;//re-entrant
  }

  String op = Operations.getOperationName(operation);

  long t = clock.getTick() - startTime;
  Timer timer = opVsTimer.computeIfAbsent(op, s -> {
    String metricName = ROOT_NAME.withTags("command", op).toString();
    return RegistryService.getMetricRegistry().timer(metricName);
  });
  timer.update(t, TimeUnit.NANOSECONDS);

}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public void onResponseReceived(HttpRequest request, HttpResponse response) {
  Long startTime = removeObjectProperty(request, START_TIME_PROPERTY_NAME);
  if (startTime == null) {
    return;
  }

  long t = Clock.defaultClock().getTick() - startTime;

  String method = request.getRequestLine().getMethod();
  int statusCode = response.getStatusLine().getStatusCode();

  String metricName = ROOT_NAME.withTags(
      "method", method,
      "status", "" + statusCode).toString();
  Timer timer = RegistryService.getMetricRegistry().timer(metricName);
  timer.update(t, TimeUnit.NANOSECONDS);

}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public void onGetInputStream(HttpURLConnection urlConnection, int statusCode) {
  Long startTime = removeObjectProperty(urlConnection, START_TIME_PROPERTY_NAME);
  if (startTime == null) {
    return;
  }

  long t = Clock.defaultClock().getTick() - startTime;
  String method = urlConnection.getRequestMethod();
  String status = "" + statusCode;
  Timer timer = timers.computeIfAbsent(status + method, s -> {
    TagEncodedMetricName metricName = ROOT_NAME.withTags(
        "method", method,
        "status", status);
    return getTimer(metricName);
  });

  timer.update(t, TimeUnit.NANOSECONDS);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
@Before
public void setUp() {
    MockitoAnnotations.initMocks(this);

    actorContext = new ActorContext(getSystem(), actorFactory.createActor(Props.create(DoNothingActor.class)),
            new MockClusterWrapper(), new MockConfiguration(), DatastoreContext.newBuilder().build(),
            new PrimaryShardInfoFutureCache()) {
        @Override
        public Timer getOperationTimer(final String operationName) {
            return commitTimer;
        }

        @Override
        public double getTxCreationLimit() {
            return 10.0;
        }
    };

    doReturn(commitTimerContext).when(commitTimer).time();
    doReturn(commitSnapshot).when(commitTimer).getSnapshot();
    for (int i = 1; i < 11; i++) {
        // Keep on increasing the amount of time it takes to complete transaction for each tenth of a
        // percentile. Essentially this would be 1ms for the 10th percentile, 2ms for 20th percentile and so on.
        doReturn(TimeUnit.MILLISECONDS.toNanos(i) * 1D).when(commitSnapshot).getValue(i * 0.1);
    }
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public static void stop(OperationId id, Supplier<Timer> timerSupplier) {
  OperationId lastId = lastId();
  if (lastId != id) {
    //TODO better error handling
    LOGGER.error("Operation Context Mismatch. Expected: " + id + " got " + lastId);
    return;
  }

  OperationContext context = CONTEXT_STACK.get().pop();
  if (context == RENTRANT) {
    return;
  }

  Timer timer = timerSupplier.get();
  if (timer != null) {
    long t = clock.getTick() - context.getStartTime();
    timer.update(t, TimeUnit.NANOSECONDS);
  }
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
@Override
public void report(final SortedMap<String, Gauge> gauges,
                   final SortedMap<String, Counter> counters,
                   final SortedMap<String, Histogram> histograms,
                   final SortedMap<String, Meter> meters,
                   final SortedMap<String, Timer> timers) {
  final long timestamp = clock.instant().toEpochMilli();

  final ImmutableList<InfluxDbMeasurement> influxDbMeasurements = ImmutableList.<InfluxDbMeasurement>builder()
    .addAll(transformer.fromGauges(gauges, timestamp))
    .addAll(transformer.fromCounters(counters, timestamp))
    .addAll(transformer.fromHistograms(histograms, timestamp))
    .addAll(transformer.fromMeters(meters, timestamp))
    .addAll(transformer.fromTimers(timers, timestamp))
    .build();

  sender.send(influxDbMeasurements);
}
 

import com.codahale.metrics.Timer; //导入依赖的package包/类
public ServiceResponse send(List<IUserAccount> users, String message, int messageType,
                            String subject, String port, String logMessage, Integer notif,
                            String eventType) throws MessageHandlingException, IOException {
  xLogger.fine("Entered send");

  // Get the address list
  List<String> addresses = getAddresses(users);
  final Timer.Context context = SMS.equals(type) ? smsTimer.time() : emailTimer.time();
  ServiceResponse resp = null;
  try {
    // Send the message and get response
    resp = doSend(addresses, message, messageType, subject, port, domainId);
  } finally {
    context.stop();
  }
  // Store the response
  if (logging) {
    logMessage(domainId, sendingUserId, logMessage != null ? logMessage : message, users, resp,
        notif, eventType);
  }
  xLogger.fine("Exiting send");
  return resp;
}