import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public MetricsFacade(Vertx vertx, HttpServer httpServer, int publicationPeriodInMillis) {
  this.httpServer = httpServer;
  this.metricsService = MetricsService.create(vertx);

  logger.info("Scheduling metrics publication every {}ms", publicationPeriodInMillis);

  // ensure that the metrics publication does *not* happen on an event loop thread
  vertx.setPeriodic(
      publicationPeriodInMillis,
      event ->
          vertx.executeBlocking(
              event1 -> {
                JsonObject metrics = metricsService.getMetricsSnapshot(httpServer);
                if (metrics != null) {
                  metricsLogger.info(metrics.encode());
                }
                event1.complete();
              },
              (Handler<AsyncResult<Void>>)
                  event12 -> {
                    // no-op
                  }));
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
private void initialize() {
    executor = vertx.createSharedWorkerExecutor("systemcontext", system().getWorkerPoolSize());
    vertx.exceptionHandler(throwable -> logger.onError(throwable));

    if (!initialized.get()) {
        MetricsService metrics = MetricsService.create(vertx);

        periodic(this::getMetricTimer, CoreStrings.LOG_METRICS, handler -> {
            if (system().isMetrics()) {
                JsonObject json = metrics.getMetricsSnapshot(vertx);
                this.onMetricsSnapshot(json);
            }
        });
        StartupListener.publish(this);
        initialized.set(true);
    }
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
/**
 * start the server, attach the route matcher
 */
private void initHTTPConnector() {
    HttpServer server = vertx.createHttpServer(new HttpServerOptions().setHost(host)
            .setPort(port));
    registerWebSocketHandler(server);
    // TODO provide a WebSocket and a EventBus access to ServiceInfo ... this must be routed through the Router to enrich the service info with metadata from the router
    routeMatcher.matchMethod(HttpMethod.GET, serviceInfoPath, request -> fetchRegitryAndUpdateMetadata((serviceInfo -> {
        request.response().putHeader("content-type", "text/json");
        request.response().end(serviceInfo.encodePrettily());
    })));
    routeMatcher.matchMethod(HttpMethod.GET,"/metrics",req -> {
        MetricsService metricsService = MetricsService.create(vertx);
        JsonObject metrics = metricsService.getMetricsSnapshot(vertx);
        req.response().putHeader("content-type", "text/json");
        req.response().end(metrics.encodePrettily());
    }) ;
    routeMatcher.noMatch(handler -> handler.response().end("no route found"));
    server.requestHandler(routeMatcher::accept).listen(res -> {

    });


}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
@Override
public void start() throws Exception {
  super.start();
  Router router = Router.router(vertx);

  // create Dropwizard metrics service
  MetricsService service = MetricsService.create(vertx);

  // event bus bridge
  SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
  BridgeOptions options = new BridgeOptions()
    .addOutboundPermitted(new PermittedOptions().setAddress("microservice.monitor.metrics"))
    .addOutboundPermitted(new PermittedOptions().setAddress("events.log"));

  sockJSHandler.bridge(options);
  router.route("/eventbus/*").handler(sockJSHandler);

  // discovery endpoint
  ServiceDiscoveryRestEndpoint.create(router, discovery);

  // static content
  router.route("/*").handler(StaticHandler.create());

  int port = config().getInteger("monitor.http.port", 9100);
  String host = config().getString("monitor.http.host", "0.0.0.0");
  int metricsInterval = config().getInteger("monitor.metrics.interval", 5000);

  vertx.createHttpServer()
    .requestHandler(router::accept)
    .listen(port, host);

  // send metrics message to the event bus
  vertx.setPeriodic(metricsInterval, t -> {
    JsonObject metrics = service.getMetricsSnapshot(vertx);
    vertx.eventBus().publish("microservice.monitor.metrics", metrics);
  });
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
private void createAndRegisterVertx() {
    VertxOptions options = new VertxOptions().setMetricsOptions(new DropwizardMetricsOptions()
            .setJmxEnabled(true)
            .setJmxDomain("vertx-metrics")
            .setRegistryName("vertx-karaf-registry")
            .setFactory(metrxFactory)
        );
            
    if (cfg.getWorkerPoolSize() > 0) {
        options.setWorkerPoolSize(cfg.getWorkerPoolSize());
    }
    
    if (cfg.getEventLoopPoolSize() > 0) {
        options.setEventLoopPoolSize(cfg.getEventLoopPoolSize());
    }
    
    if (cfg.getHAEnabled()) {
        options.setHAEnabled(cfg.getHAEnabled());
        if (cfg.getHAGroup() != null && !cfg.getHAGroup().isEmpty()) {
            options.setHAGroup(cfg.getHAGroup());
        }
    }
    
    if (clusterManager != null) {
        LOGGER.info("Starting vertx with cluster manager");
        options.setClusterManager(clusterManager);
    }

    try {
        vertx = executeWithTCCLSwitch(() -> Vertx.vertx(options));
    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, "Error while creating vertx system", e);
        return;
    }
    
    vertxRegistration = bundleContext.registerService(Vertx.class, vertx, null);
    LOGGER.info("Vert.x service registered");
    ebRegistration = bundleContext.registerService(EventBus.class, vertx.eventBus(), null);
    LOGGER.info("Vert.x Event Bus service registered");
    registry = SharedMetricRegistries.getOrCreate("vertx-karaf-registry");
    metricsRegistration = bundleContext.registerService(MetricRegistry.class, registry, null);
    LOGGER.info("Vert.x MetricsService service registered");
    MetricsService metricsService = MetricsService.create(vertx);
    metricsServiceRegistration = bundleContext.registerService(MetricsService.class, metricsService, null);
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
ApiMetricCmd(Vertx vertx) {
  this.metricsService = MetricsService.create(vertx);
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public static MetricsService getServerMetrics(){
  return serverMetrics;
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public void naming1(Vertx vertx, MetricsService metricsService) {
  JsonObject metrics = metricsService.getMetricsSnapshot(vertx);
  metrics.getJsonObject("vertx.eventbus.handlers");
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public void naming2(Vertx vertx, MetricsService metricsService) {
  EventBus eventBus = vertx.eventBus();
  JsonObject metrics = metricsService.getMetricsSnapshot(eventBus);
  metrics.getJsonObject("handlers");
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public void naming3(Vertx vertx, MetricsService metricsService) {
  Set<String> metricsNames = metricsService.metricsNames();
  for (String metricsName : metricsNames) {
    System.out.println("Known metrics name " + metricsName);
  }
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public void example1(Vertx vertx) {
  MetricsService metricsService = MetricsService.create(vertx);
  JsonObject metrics = metricsService.getMetricsSnapshot(vertx);
  System.out.println(metrics);
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public void example2(Vertx vertx) {
  MetricsService metricsService = MetricsService.create(vertx);
  HttpServer server = vertx.createHttpServer();
  // set up server
  JsonObject metrics = metricsService.getMetricsSnapshot(server);
}
 

import io.vertx.ext.dropwizard.MetricsService; //导入依赖的package包/类
public void example3(Vertx vertx) {
  MetricsService metricsService = MetricsService.create(vertx);
  JsonObject metrics = metricsService.getMetricsSnapshot("vertx.eventbus.message");
}