Refine search
TimingInfo timingInfo = metrics.getTimingInfo(); Number requestCounts = timingInfo.getCounter(RequestCount.name()); Number retryCounts = timingInfo.getCounter(HttpClientRetryCount.name()); Number throttleExceptions = timingInfo.getCounter(ThrottleException.name()); TimingInfo requestTime = timingInfo.getSubMeasurement(HttpRequestTime.name()); TimingInfo clientExecuteTime = timingInfo.getSubMeasurement(ClientExecuteTime.name()); if (requestTime != null && requestTime.getTimeTakenMillisIfKnown() != null) { stats.addAwsRequestTime(new Duration(requestTime.getTimeTakenMillisIfKnown(), MILLISECONDS)); if (clientExecuteTime != null && clientExecuteTime.getTimeTakenMillisIfKnown() != null) { stats.addAwsClientExecuteTime(new Duration(clientExecuteTime.getTimeTakenMillisIfKnown(), MILLISECONDS));
/** * End an event which was previously started. Once ended, log how much time * the event took. It is illegal to end an Event that was not started. It is * good practice to endEvent in a finally block. See Also startEvent. * * @param eventName * - The name of the event to start */ @Override public void endEvent(String eventName) { TimingInfo event = eventsBeingProfiled.get(eventName); /* Somebody tried to end an event that was not started. */ if (event == null) { LogFactory.getLog(getClass()).warn ("Trying to end an event which was never started: " + eventName); return; } event.endTiming(); this.timingInfo.addSubMeasurement( eventName, TimingInfo.unmodifiableTimingInfo( event.getStartEpochTimeMilliIfKnown(), event.getStartTimeNano(), event.getEndTimeNano())); }
@Deprecated public final long getEndEpochTimeMilli() { Long v = getEndEpochTimeMilliIfKnown(); return v == null ? UNKNOWN : v.longValue(); }
public final Double getTimeTakenMillisIfKnown() { return isEndTimeKnown() ? durationMilliOf(startTimeNano, endTimeNano) : null ; }
public final Long getEndEpochTimeMilliIfKnown() { return isStartEpochTimeMilliKnown() && isEndTimeKnown() // make use of the wall clock time and elpased time ? startEpochTimeMilli.longValue() + TimeUnit.NANOSECONDS.toMillis(endTimeNano.longValue() - startTimeNano) : null; }
/** * Convenient method to end the client execution without logging the awsRequestMetrics. */ private void endClientExecution(AWSRequestMetrics awsRequestMetrics, RequestConfig requestConfig, Request<?> request, Response<?> response) { if (request != null) { awsRequestMetrics.endEvent(AWSRequestMetrics.Field.ClientExecuteTime); awsRequestMetrics.getTimingInfo().endTiming(); RequestMetricCollector metricCollector = findRequestMetricCollector(requestConfig); metricCollector.collectMetrics(request, response); awsRequestMetrics.log(); } }
response = executeHelper(); publishProgress(listener, ProgressEventType.CLIENT_REQUEST_SUCCESS_EVENT); awsRequestMetrics.endEvent(AwsClientSideMonitoringMetrics.ApiCallLatency); awsRequestMetrics.getTimingInfo().endTiming(); afterResponse(response); return response; publishProgress(listener, ProgressEventType.CLIENT_REQUEST_FAILED_EVENT); awsRequestMetrics.endEvent(AwsClientSideMonitoringMetrics.ApiCallLatency);
@Test public void newTimingWithNoClockTimeIfKnown() throws InterruptedException { final long startTimeNano = System.nanoTime(); Thread.sleep(1);// sleep for 1 millisecond final long endTimeNano = System.nanoTime(); TimingInfo ti = TimingInfo.newTimingInfoFullSupport(startTimeNano, endTimeNano); assertFalse(ti.isStartEpochTimeMilliKnown()); assertTrue(ti.getStartTimeNano() == startTimeNano); assertNull(ti.getStartEpochTimeMilliIfKnown()); assertTrue(ti.isEndTimeKnown()); assertTrue(ti.getEndTimeNanoIfKnown().longValue() > startTimeNano); assertNull(ti.getEndEpochTimeMilliIfKnown()); assertTrue(ti.getTimeTakenMillisIfKnown().longValue() >= 0); }
@Test public void newTimingWithNoClockTime() throws InterruptedException { final long startTimeNano = System.nanoTime(); Thread.sleep(1);// sleep for 1 millisecond final long endTimeNano = System.nanoTime(); TimingInfo ti = TimingInfo.newTimingInfoFullSupport(startTimeNano, endTimeNano); assertFalse(ti.isStartEpochTimeMilliKnown()); assertTrue(ti.getStartTimeNano() == startTimeNano); assertTrue(ti.getStartEpochTimeMilli() == UNKNOWN); assertTrue(ti.isEndTimeKnown()); assertTrue(ti.getEndTimeNano() > startTimeNano); assertTrue(ti.getEndEpochTimeMilli() == UNKNOWN); assertTrue(ti.getEndTime() == ti.getEndEpochTimeMilli()); assertTrue(ti.getTimeTakenMillis() >= 0); assertTrue(ti.getElapsedTimeMillis() >= 0); }
Field metricType, Request<?> req, Object resp) { AWSRequestMetrics m = req.getAWSRequestMetrics(); TimingInfo ti = m.getTimingInfo(); Number counter = ti.getCounter(Field.RequestCount.name()); if (counter == null) {
@Override public void collectMetrics(Request<?> request, Response<?> response) { final AWSRequestMetrics metrics = request.getAWSRequestMetrics(); if (metrics.isEnabled()) { final Map<String, String> allTags = getAllTags(request); final TimingInfo timing = metrics.getTimingInfo(); for (Field counter : COUNTERS) { Optional.ofNullable(timing.getCounter(counter.name())) .filter(v -> v.longValue() > 0) .ifPresent(v -> registry.counter(metricId(counter, allTags)).increment(v.longValue())); } for (Field timer : TIMERS) { Optional.ofNullable(timing.getLastSubMeasurement(timer.name())) .filter(TimingInfo::isEndTimeKnown) .ifPresent(t -> registry.timer(metricId(timer, allTags)) .record(t.getEndTimeNano() - t.getStartTimeNano(), TimeUnit.NANOSECONDS)); } notEmpty(metrics.getProperty(Field.ThrottleException)).ifPresent(throttleExceptions -> { final Id throttling = metricId("throttling", allTags); throttleExceptions.forEach(ex -> registry.counter(throttling.withTag(TAG_THROTTLE_EXCEPTION, ex.getClass().getSimpleName())).increment()); }); } }
@Test public void startEndTimingIfKnown() { // Start timing final long startTimeNano = System.nanoTime(); final long startTimeMilli = System.currentTimeMillis(); TimingInfo ti = TimingInfo.startTimingFullSupport(); assertTrue(ti.isStartEpochTimeMilliKnown()); assertTrue(ti.getStartTimeNano() >= startTimeNano); assertTrue(ti.getStartEpochTimeMilliIfKnown().longValue() >= startTimeMilli); // End time is not known assertFalse(ti.isEndTimeKnown()); assertNull(ti.getEndTimeNanoIfKnown()); assertNull(ti.getEndEpochTimeMilliIfKnown()); assertNull(ti.getTimeTakenMillisIfKnown()); // End timing ti.endTiming(); assertTrue(ti.isEndTimeKnown()); assertTrue(ti.getEndTimeNanoIfKnown().longValue() >= startTimeNano); assertTrue(ti.getEndEpochTimeMilliIfKnown().longValue() >= startTimeMilli); assertTrue(ti.getEndEpochTimeMilli() == ti.getEndEpochTimeMilliIfKnown().longValue()); assertTrue(ti.getTimeTakenMillisIfKnown().longValue() >= 0); }
@Test public void startEndTiming() { // Start timing final long startTimeNano = System.nanoTime(); final long startTimeMilli = System.currentTimeMillis(); TimingInfo[] tis = { TimingInfo.startTimingFullSupport(), TimingInfo.startTiming() }; for (TimingInfo ti : tis) { assertTrue(ti.isStartEpochTimeMilliKnown()); assertTrue(ti.getStartTimeNano() >= startTimeNano); assertTrue(ti.getStartEpochTimeMilli() >= startTimeMilli); // End time is not known assertFalse(ti.isEndTimeKnown()); assertTrue(ti.getEndTimeNano() == UNKNOWN); assertTrue(ti.getEndEpochTimeMilli() == UNKNOWN); assertTrue(ti.getEndTime() == ti.getEndEpochTimeMilli()); assertTrue(ti.getTimeTakenMillis() == UNKNOWN); assertTrue(ti.getElapsedTimeMillis() == UNKNOWN); // End timing ti.endTiming(); assertTrue(ti.isEndTimeKnown()); assertTrue(ti.getEndTimeNano() >= startTimeNano); assertTrue(ti.getEndEpochTimeMilli() >= startTimeMilli); assertTrue(ti.getEndTime() == ti.getEndEpochTimeMilli()); assertTrue(ti.getTimeTakenMillis() >= 0); assertTrue(ti.getElapsedTimeMillis() >= 0); } }
TimingInfo timingInfo = metrics == null ? null : metrics.getTimingInfo(); Long attemptLatency = null; if (timingInfo != null && timingInfo.getLastSubMeasurement(HttpRequestTime.name()) != null) { httpRequestTime = timingInfo.getLastSubMeasurement(HttpRequestTime.name()); timestamp = httpRequestTime.getStartEpochTimeMilliIfKnown(); attemptLatency = convertToLongIfNotNull(httpRequestTime.getTimeTakenMillisIfKnown());
Request<?> req, Object response, boolean includesRequestType) { AWSRequestMetrics m = req.getAWSRequestMetrics(); TimingInfo root = m.getTimingInfo(); final String metricName = metricType.name(); List<TimingInfo> subMeasures = root.getAllSubMeasurements(metricName); if (subMeasures != null) { List<MetricDatum> result = new ArrayList<MetricDatum>(subMeasures.size()); for (TimingInfo sub : subMeasures) { if (sub.isEndTimeKnown()) { // being defensive List<Dimension> dims = new ArrayList<Dimension>(); dims.add(new Dimension() .withDimensions(dims) .withUnit(StandardUnit.Milliseconds) .withValue(sub.getTimeTakenMillisIfKnown()); result.add(datum);
/** * Returns a request type specific metrics for * {@link Field#ClientExecuteTime} which is special in the sense that it * makes a more accurate measurement by taking the {@link TimingInfo} at the * root into account. */ protected List<MetricDatum> latencyOfClientExecuteTime(Request<?> req, Object response) { AWSRequestMetrics m = req.getAWSRequestMetrics(); TimingInfo root = m.getTimingInfo(); final String metricName = Field.ClientExecuteTime.name(); if (root.isEndTimeKnown()) { // being defensive List<Dimension> dims = new ArrayList<Dimension>(); dims.add(new Dimension() .withName(Dimensions.MetricType.name()) .withValue(metricName)); // request type specific dims.add(new Dimension() .withName(Dimensions.RequestType.name()) .withValue(requestType(req))); MetricDatum datum = new MetricDatum() .withMetricName(req.getServiceName()) .withDimensions(dims) .withUnit(StandardUnit.Milliseconds) .withValue(root.getTimeTakenMillisIfKnown()); return Collections.singletonList(datum); } return Collections.emptyList(); }
response = executeHelper(request, responseHandler, errorResponseHandler, executionContext); final TimingInfo timingInfo = awsRequestMetrics.getTimingInfo().endTiming(); afterResponse(request, requestHandler2s, response, timingInfo); return response;
private void execRequest(String endpoint, int status) { AWSRequestMetrics metrics = new AWSRequestMetricsFullSupport(); metrics.addProperty(AWSRequestMetrics.Field.ServiceName, "AmazonCloudWatch"); metrics.addProperty(AWSRequestMetrics.Field.ServiceEndpoint, endpoint); metrics.addProperty(AWSRequestMetrics.Field.StatusCode, "" + status); if (status == 503) { metrics.addProperty(AWSRequestMetrics.Field.AWSErrorCode, "Throttled"); } String counterName = "BytesProcessed"; String timerName = "ClientExecuteTime"; metrics.setCounter(counterName, 12345); metrics.getTimingInfo().addSubMeasurement(timerName, TimingInfo.unmodifiableTimingInfo(100000L, 200000L)); Request<?> req = new DefaultRequest(new ListMetricsRequest(), "AmazonCloudWatch"); req.setAWSRequestMetrics(metrics); req.setEndpoint(URI.create(endpoint)); HttpResponse hr = new HttpResponse(req, new HttpPost(endpoint)); hr.setStatusCode(status); Response<?> resp = new Response<>(null, new HttpResponse(req, new HttpPost(endpoint))); collector.collectMetrics(req, resp); }
@Test public void subEventsDisabled() { TimingInfo ti = TimingInfo.startTiming(); ti.addSubMeasurement("m1", TimingInfo.startTiming()); assertNull(ti.getAllSubMeasurements("m1")); ti.incrementCounter("c1"); assertTrue(ti.getAllCounters().size() == 0); ti.setCounter("c2", 0); assertTrue(ti.getAllCounters().size() == 0); }
@Test public void subEventsEnabled() { TimingInfo ti = TimingInfo.startTimingFullSupport(); ti.addSubMeasurement("m1", TimingInfo.startTimingFullSupport()); assertNotNull(ti.getAllSubMeasurements("m1")); ti.incrementCounter("c1"); assertTrue(ti.getAllCounters().size() == 1); ti.setCounter("c2", 0); assertTrue(ti.getAllCounters().size() == 2); }