Java Markers类代码示例

import net.logstash.logback.marker.Markers; //导入依赖的package包/类
/**
 * This method handles the webhook from the payment provider. It requests the status of the order with the given
 * reference
 *
 * @param orderReference Id of the order at the paymentprovider, stored in the reference field
 *
 * @return Statusmessage
 */
@PostMapping("/status")
public ResponseEntity<?> updateOrderStatus(@RequestParam(name = "id") String orderReference) {
    // Fields for logging
    Marker mollieMarker = Markers.append("request_source", "webhook");
    StructuredArgument logOrderReference = StructuredArguments.value("order_reference", orderReference);

    log.info(mollieMarker, "Incoming paymentprovicer webhook for reference: {}", orderReference, logOrderReference);
    try {
        orderService.updateOrderStatusByReference(orderReference);
    } catch (OrderNotFoundException e) {
        log.warn(mollieMarker, "Paymentprovider webhook reference could not be found: {}", orderReference,
                logOrderReference);
    }
    return createResponseEntity(HttpStatus.OK, "Status is being updated");
}
 

import net.logstash.logback.marker.Markers; //导入依赖的package包/类
/**
 * Calculate and report the three parameters of Little's Law and some latency percentiles.
 *
 * <p>This just writes them to stdout, but presumably we'd be reporting them to a centralized
 * service.
 */
private void report() {
  LogstashMarker marker =
      Markers.append("all", all.interval())
          .and(Markers.append("bytes_in", bytesIn.interval()))
          .and(Markers.append("bytes_out", bytesOut.interval()));
  for (Entry<String, Recorder> entry : endpoints.entrySet()) {
    marker = marker.and(Markers.append(entry.getKey(), entry.getValue().interval()));
  }
  LOGGER.info(marker, "stats");
}
 

import net.logstash.logback.marker.Markers; //导入依赖的package包/类
@Override
public void run() {
  try {
    final TlsContext tls = new TlsContext(trustedCertsPath, certPath, keyPath);
    final HelloWorldClient client = new HelloWorldClient(hostname, port, tls);
    try {
      final Recorder recorder =
          new Recorder(
              500,
              TimeUnit.MINUTES.toMicros(1),
              TimeUnit.MILLISECONDS.toMicros(10),
              TimeUnit.MICROSECONDS);
      LOGGER.info("Initial request: {}", client.greet(requests));
      LOGGER.info("Sending {} requests from {} threads", requests, threads);

      final ExecutorService threadPool = Executors.newFixedThreadPool(threads);
      final Instant start = Instant.now();
      for (int i = 0; i < threads; i++) {
        threadPool.execute(
            () -> {
              for (int j = 0; j < requests / threads; j++) {
                final long t = System.nanoTime();
                client.greet(j);
                recorder.record(t);
              }
            });
      }
      threadPool.shutdown();
      threadPool.awaitTermination(20, TimeUnit.MINUTES);

      final Snapshot stats = recorder.interval();
      final Duration duration = Duration.between(start, Instant.now());
      LOGGER.info(
          Markers.append("stats", stats).and(Markers.append("duration", duration.toString())),
          "{} requests in {} ({} req/sec)",
          stats.count(),
          duration,
          stats.throughput());
    } finally {
      client.shutdown();
    }
  } catch (SSLException | InterruptedException e) {
    LOGGER.error("Error running command", e);
  }
}