io.vertx.core.spi.metrics.ClientMetrics Java Examples

@Test
public void testClientMetricsLifecycle() {
  VertxMetrics spi = ((VertxInternal) vertx).metricsSPI();
  SocketAddress address = SocketAddress.inetSocketAddress(8080, "localhost");
  ClientMetrics[] metrics = new ClientMetrics[2];
  for (int i = 0;i < metrics.length;i++) {
    metrics[i] = spi.createClientMetrics(address, "backend", "acme");
  }
  JsonObject snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.acme.localhost:8080");
  assertTrue(snapshot.size() > 0);
  metrics[0].close();
  snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.acme.localhost:8080");
  assertTrue(snapshot.size() > 0);
  metrics[1].close();
  snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.acme.localhost:8080");
  assertTrue(snapshot.size() == 0);
}
 

@Test
public void testClientMetricsReporting() {
  SocketAddress address = SocketAddress.inetSocketAddress(8080, "localhost");
  ClientMetrics metrics = ((VertxInternal) vertx).metricsSPI().createClientMetrics(address, "backend", null);

  // Queue
  Object queueMetric = metrics.enqueueRequest();
  JsonObject snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.localhost:8080");
  assertEquals(1, (int)snapshot.getJsonObject("vertx.backend.clients.localhost:8080.queue-size").getInteger("count"));
  metrics.dequeueRequest(queueMetric);
  snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.localhost:8080");
  assertEquals(0, (int)snapshot.getJsonObject("vertx.backend.clients.localhost:8080.queue-size").getInteger("count"));
  assertEquals(1, (int)snapshot.getJsonObject("vertx.backend.clients.localhost:8080.queue-delay").getInteger("count"));

  // Request
  Object request = new Object();
  Object response = new Object();
  Object requestMetric = metrics.requestBegin("some-uri", request);
  metrics.requestEnd(requestMetric);
  metrics.responseBegin(requestMetric, response);
  snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.localhost:8080");
  assertEquals(0, (int)snapshot.getJsonObject("vertx.backend.clients.localhost:8080.requests").getInteger("count"));
  metrics.responseEnd(requestMetric, response);
  snapshot = metricsService.getMetricsSnapshot("vertx.backend.clients.localhost:8080");
  assertEquals(1, (int)snapshot.getJsonObject("vertx.backend.clients.localhost:8080.requests").getInteger("count"));
}
 

@Override
public synchronized ClientMetrics<?, ?, ?, ?> createClientMetrics(SocketAddress remoteAddress, String type, String namespace) {
  String baseName;
  if (namespace != null && namespace.length() > 0) {
    baseName = MetricRegistry.name(nameOf(type, "clients", namespace, remoteAddress.toString()));
  } else {
    baseName = MetricRegistry.name(nameOf(type, "clients", remoteAddress.toString()));
  }
  return clientMetrics.compute(baseName, (key, prev) -> {
    if (prev == null) {
      return new DropwizardClientMetrics<>(this, registry, baseName, 1);
    } else {
      return prev.inc();
    }
  });
}
 

public static PgPoolImpl create(ContextInternal context, boolean closeVertx, PgConnectOptions connectOptions, PoolOptions poolOptions) {
  QueryTracer tracer = context.tracer() == null ? null : new QueryTracer(context.tracer(), connectOptions);
  VertxMetrics vertxMetrics = context.owner().metricsSPI();
  ClientMetrics metrics = vertxMetrics != null ? vertxMetrics.createClientMetrics(connectOptions.getSocketAddress(), "sql", connectOptions.getMetricsName()) : null;
  PgPoolImpl pool = new PgPoolImpl(context, new PgConnectionFactory(context.owner(), context, connectOptions), tracer, metrics, poolOptions);
  CloseFuture closeFuture = pool.closeFuture();
  if (closeVertx) {
    closeFuture.onComplete(ar -> context.owner().close());
  } else {
    context.addCloseHook(closeFuture);
  }
  return pool;
}
 

@Override
public ClientMetrics<HttpClientRequestMetric, Timer.Context, HttpClientRequest, HttpClientResponse> createEndpointMetrics(SocketAddress remoteAddress, int maxPoolSize) {
  String name = remoteAddress.toString();
  if (endpointMatcher.matches(name) != null) {
    return new EndpointMetrics(clientReporter, name, uriMatcher);
  } else {
    return null;
  }
}
 

public static MySQLPoolImpl create(ContextInternal context, boolean closeVertx, MySQLConnectOptions connectOptions, PoolOptions poolOptions) {
  QueryTracer tracer = context.tracer() == null ? null : new QueryTracer(context.tracer(), connectOptions);
  VertxMetrics vertxMetrics = context.owner().metricsSPI();
  ClientMetrics metrics = vertxMetrics != null ? vertxMetrics.createClientMetrics(connectOptions.getSocketAddress(), "sql", connectOptions.getMetricsName()) : null;
  MySQLPoolImpl pool = new MySQLPoolImpl(context, new MySQLConnectionFactory(context, connectOptions), tracer, metrics, poolOptions);
  CloseFuture closeFuture = pool.closeFuture();
  if (closeVertx) {
    closeFuture.onComplete(ar -> context.owner().close());
  } else {
    context.addCloseHook(closeFuture);
  }
  return pool;
}
 

private static void connect(MySQLConnectionFactory client, ContextInternal ctx, QueryTracer tracer, ClientMetrics metrics, Promise<MySQLConnection> promise) {
  client.connect()
    .map(conn -> {
      MySQLConnectionImpl mySQLConnection = new MySQLConnectionImpl(client, ctx, conn, tracer, metrics);
      conn.init(mySQLConnection);
      return (MySQLConnection) mySQLConnection;
    }).onComplete(promise);
}
 

@Test
public void testClosePool(TestContext ctx) {
  AtomicInteger closeCount = new AtomicInteger();
  metrics = new ClientMetrics() {
    @Override
    public void close() {
      closeCount.incrementAndGet();
    }
  };
  Pool pool = createPool(vertx);
  ctx.assertEquals(0, closeCount.get());
  pool.close(ctx.asyncAssertSuccess(v -> {
    ctx.assertEquals(1, closeCount.get());
  }));
}
 

@Before
public void setup() {
  vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(
    new MetricsOptions().setEnabled(true).setFactory(tracingOptions -> new VertxMetrics() {
      @Override
      public ClientMetrics<?, ?, ?, ?> createClientMetrics(SocketAddress remoteAddress, String type, String namespace) {
        return metrics;
      }
    }))
  );
}
 

public PoolBase(ContextInternal context, ConnectionFactory factory, QueryTracer tracer, ClientMetrics metrics, PoolOptions poolOptions) {
  super(tracer, metrics);
  this.vertx = context.owner();
  this.factory = factory;
  this.pool = new ConnectionPool(factory, context, poolOptions.getMaxSize(), poolOptions.getMaxWaitQueueSize());
  this.closeFuture = new CloseFuture(this);
}
 

public QueryExecutor(QueryTracer tracer,
                     ClientMetrics metrics,
                     Function<T, R> factory,
                     Collector<Row, ?, T> collector) {
  this.tracer = tracer;
  this.metrics = metrics;
  this.factory = factory;
  this.collector = collector;
}
 

QueryResultBuilder(Function<T, R> factory, QueryTracer tracer, Object tracingPayload, ClientMetrics metrics, Object metric, Promise<L> handler) {
  this.factory = factory;
  this.context = (ContextInternal) handler.future().context();
  this.tracer = tracer;
  this.tracingPayload = tracingPayload;
  this.metrics = metrics;
  this.metric = metric;
  this.handler = handler;
}
 

public static DB2PoolImpl create(ContextInternal context, boolean closeVertx, DB2ConnectOptions connectOptions,
                                 PoolOptions poolOptions) {
  QueryTracer tracer = context.tracer() == null ? null : new QueryTracer(context.tracer(), connectOptions);
  VertxMetrics vertxMetrics = context.owner().metricsSPI();
  ClientMetrics metrics = vertxMetrics != null ? vertxMetrics.createClientMetrics(connectOptions.getSocketAddress(), "sql", connectOptions.getMetricsName()) : null;
  DB2PoolImpl pool = new DB2PoolImpl(context, poolOptions, new DB2ConnectionFactory(context, connectOptions), tracer, metrics);
  CloseFuture closeFuture = pool.closeFuture();
  if (closeVertx) {
    closeFuture.onComplete(ar -> context.owner().close());
  } else {
    context.addCloseHook(closeFuture);
  }
  return pool;
}
 

public static MSSQLPoolImpl create(ContextInternal context, boolean closeVertx, MSSQLConnectOptions connectOptions, PoolOptions poolOptions) {
  QueryTracer tracer = context.tracer() == null ? null : new QueryTracer(context.tracer(), connectOptions);
  VertxMetrics vertxMetrics = context.owner().metricsSPI();
  ClientMetrics metrics = vertxMetrics != null ? vertxMetrics.createClientMetrics(connectOptions.getSocketAddress(), "sql", connectOptions.getMetricsName()) : null;
  MSSQLPoolImpl pool = new MSSQLPoolImpl(context, new MSSQLConnectionFactory(context, connectOptions), tracer, metrics, poolOptions);
  CloseFuture closeFuture = pool.closeFuture();
  if (closeVertx) {
    closeFuture.onComplete(ar -> context.owner().close());
  } else {
    context.addCloseHook(closeFuture);
  }
  return pool;
}
 

private PreparedStatementImpl(Connection conn, QueryTracer tracer, ClientMetrics metrics, ContextInternal context, io.vertx.sqlclient.impl.PreparedStatement ps, boolean autoCommit) {
  this.conn = conn;
  this.tracer = tracer;
  this.metrics = metrics;
  this.context = context;
  this.ps = ps;
  this.autoCommit = autoCommit;
}
 

public MySQLConnectionImpl(MySQLConnectionFactory factory, ContextInternal context, Connection conn, QueryTracer tracer, ClientMetrics metrics) {
  super(context, conn, tracer, metrics);

  this.factory = factory;
}
 

PgConnectionImpl(PgConnectionFactory factory, ContextInternal context, Connection conn, QueryTracer tracer, ClientMetrics metrics) {
  super(context, conn, tracer, metrics);

  this.factory = factory;
}
 

private PgPoolImpl(ContextInternal context, PgConnectionFactory factory, QueryTracer tracer, ClientMetrics metrics, PoolOptions poolOptions) {
  super(context, factory, tracer, metrics, poolOptions);
  this.factory = factory;
}
 

public DB2ConnectionImpl(DB2ConnectionFactory factory, ContextInternal context, Connection conn, QueryTracer tracer, ClientMetrics metrics) {
  super(context, conn, tracer, metrics);
}
 

@Override
public void endpointDisconnected(ClientMetrics<HttpClientRequestMetric, Timer.Context, ?, ?> endpointMetric) {
  if (endpointMetric instanceof EndpointMetrics) {
    ((EndpointMetrics)endpointMetric).openConnections.dec();
  }
}
 

@Override
public void endpointConnected(ClientMetrics<HttpClientRequestMetric, Timer.Context, ?, ?> endpointMetric) {
  if (endpointMetric instanceof EndpointMetrics) {
    ((EndpointMetrics)endpointMetric).openConnections.inc();
  }
}
 

private MySQLPoolImpl(ContextInternal context, MySQLConnectionFactory factory, QueryTracer tracer, ClientMetrics metrics, PoolOptions poolOptions) {
  super(context, factory, tracer, metrics, poolOptions);
  this.factory = factory;
}
 

private DB2PoolImpl(ContextInternal context, PoolOptions poolOptions, DB2ConnectionFactory factory, QueryTracer tracer, ClientMetrics metrics) {
  super(context, factory, tracer, metrics, poolOptions);
  this.factory = factory;
}
 

private MSSQLPoolImpl(ContextInternal context, MSSQLConnectionFactory factory, QueryTracer tracer, ClientMetrics metrics, PoolOptions poolOptions) {
  super(context, factory, tracer, metrics, poolOptions);
  this.connectionFactory = factory;
}
 

public MSSQLConnectionImpl(MSSQLConnectionFactory factory, ContextInternal context, Connection conn, QueryTracer tracer, ClientMetrics metrics) {
  super(context, conn, tracer, metrics);
  this.factory = factory;
}
 

public SqlConnectionImpl(ContextInternal context, Connection conn, QueryTracer tracer, ClientMetrics metrics) {
  super(context, conn, tracer, metrics);
}
 

protected SqlConnectionBase(ContextInternal context, Connection conn, QueryTracer tracer, ClientMetrics metrics) {
  super(tracer, metrics);
  this.context = context;
  this.conn = conn;
}
 

ClientMetrics metrics() {
  return metrics;
}
 

public SqlClientBase(QueryTracer tracer, ClientMetrics metrics) {
  this.tracer = tracer;
  this.metrics = metrics;
}
 

static PreparedStatement create(Connection conn, QueryTracer tracer, ClientMetrics metrics, ContextInternal context, io.vertx.sqlclient.impl.PreparedStatement ps, boolean autoCommit) {
  return new PreparedStatementImpl(conn, tracer, metrics, context, ps, autoCommit);
}