org.apache.calcite.avatica.metrics.MetricsSystem Java Examples

public DynamicAvaticaJsonHandler(KarelDbConfig config, AvaticaHandler localHandler, UrlProvider urlProvider,
                                 MetricsSystem metrics,
                                 AvaticaServerConfiguration serverConfig) {
    this.config = config;
    this.localHandler = Objects.requireNonNull(localHandler);
    this.urlProvider = Objects.requireNonNull(urlProvider);
    this.metrics = Objects.requireNonNull(metrics);

    // Metrics
    this.requestTimer = this.metrics.getTimer(
        concat(AvaticaJsonHandler.class, MetricsAwareAvaticaHandler.REQUEST_TIMER_NAME));

    this.threadLocalBuffer = ThreadLocal.withInitial(UnsynchronizedBuffer::new);

    this.serverConfig = serverConfig;
}
 

/**
 * Constructs the desired implementation for the given serialization method and server
 * configuration with metrics.
 *
 * @param service The underlying {@link Service}
 * @param serialization The serializatio mechanism to use
 * @param metricsConfig Configuration for the {@link MetricsSystem}.
 * @param serverConfig Avatica server configuration or null
 * @return An {@link AvaticaHandler}
 */
public AvaticaHandler getHandler(Service service, Driver.Serialization serialization,
    MetricsSystemConfiguration<?> metricsConfig, AvaticaServerConfiguration serverConfig) {
  if (null == metricsConfig) {
    metricsConfig = NoopMetricsSystemConfiguration.getInstance();
  }
  MetricsSystem metrics = MetricsSystemLoader.load(metricsConfig);

  switch (serialization) {
  case JSON:
    return new AvaticaJsonHandler(service, metrics, serverConfig);
  case PROTOBUF:
    return new AvaticaProtobufHandler(service, metrics, serverConfig);
  default:
    throw new IllegalArgumentException("Unknown Avatica handler for " + serialization.name());
  }
}
 

public AvaticaJsonHandler(Service service, MetricsSystem metrics,
    AvaticaServerConfiguration serverConfig) {
  this.service = Objects.requireNonNull(service);
  this.metrics = Objects.requireNonNull(metrics);
  // Avatica doesn't have a Guava dependency
  this.jsonHandler = new JsonHandler(service, this.metrics);

  // Metrics
  this.requestTimer = this.metrics.getTimer(
      concat(AvaticaJsonHandler.class, MetricsAwareAvaticaHandler.REQUEST_TIMER_NAME));

  this.threadLocalBuffer = new ThreadLocal<UnsynchronizedBuffer>() {
    @Override public UnsynchronizedBuffer initialValue() {
      return new UnsynchronizedBuffer();
    }
  };

  this.serverConfig = serverConfig;
}
 

public AvaticaProtobufHandler(Service service, MetricsSystem metrics,
    AvaticaServerConfiguration serverConfig) {
  this.service = Objects.requireNonNull(service);
  this.metrics = Objects.requireNonNull(metrics);

  this.requestTimer = this.metrics.getTimer(
      MetricsHelper.concat(AvaticaProtobufHandler.class,
          MetricsAwareAvaticaHandler.REQUEST_TIMER_NAME));

  this.protobufTranslation = new ProtobufTranslationImpl();
  this.pbHandler = new ProtobufHandler(service, protobufTranslation, metrics);

  this.threadLocalBuffer = new ThreadLocal<UnsynchronizedBuffer>() {
    @Override public UnsynchronizedBuffer initialValue() {
      return new UnsynchronizedBuffer();
    }
  };

  this.serverConfig = serverConfig;
}
 

public LocalService(Meta meta, MetricsSystem metrics) {
  this.meta = meta;
  this.metrics = Objects.requireNonNull(metrics);

  this.executeTimer = this.metrics.getTimer(name("Execute"));
  this.commitTimer = this.metrics.getTimer(name("Commit"));
  this.prepareTimer = this.metrics.getTimer(name("Prepare"));
  this.prepareAndExecuteTimer = this.metrics.getTimer(name("PrepareAndExecute"));
  this.connectionSyncTimer = this.metrics.getTimer(name("ConnectionSync"));
}
 

@Test public void testNoNulls() {
  // The NOOP implementation should act as a real implementation, no "nulls" allowed.
  MetricsSystem metrics = NoopMetricsSystem.getInstance();

  Counter counter = metrics.getCounter("counter");
  counter.decrement();
  counter.increment();
  counter.decrement(1L);
  counter.increment(1L);

  Histogram histogram = metrics.getHistogram("histogram");
  histogram.update(1);
  histogram.update(1L);

  Timer timer = metrics.getTimer("timer");
  Context context = timer.start();
  context.close();
  Context contextTwo = timer.start();
  assertTrue("Timer's context should be a singleton", context == contextTwo);

  Meter meter = metrics.getMeter("meter");
  meter.mark();
  meter.mark(5L);

  metrics.register("gauge", new Gauge<Long>() {
    @Override public Long getValue() {
      return 42L;
    }
  });
}
 

public ProtobufHandler(Service service, ProtobufTranslation translation, MetricsSystem metrics) {
  super(service);
  this.translation = translation;
  this.metrics = metrics;
  this.serializationTimer = this.metrics.getTimer(
      MetricsHelper.concat(ProtobufHandler.class, HANDLER_SERIALIZATION_METRICS_NAME));
}
 

public JsonHandler(Service service, MetricsSystem metrics) {
  super(service);
  this.metrics = metrics;
  this.serializationTimer = this.metrics.getTimer(
      MetricsHelper.concat(JsonHandler.class, HANDLER_SERIALIZATION_METRICS_NAME));
}
 

public DynamicAvaticaJsonHandler(KarelDbConfig config, AvaticaHandler localHandler, UrlProvider urlProvider,
                                 MetricsSystem metrics) {
    this(config, localHandler, urlProvider, metrics, null);
}
 

@Override public MetricsSystem getMetrics() {
  return metrics;
}
 

public AvaticaJsonHandler(Service service, MetricsSystem metrics) {
  this(service, metrics, null);
}
 

@Override public MetricsSystem getMetrics() {
  return this.metrics;
}
 

public AvaticaProtobufHandler(Service service, MetricsSystem metrics) {
  this(service, metrics, null);
}
 

/**
 * Creates a JdbcMeta.
 *
 * @param url a database url of the form
 * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
 * @param info a list of arbitrary string tag/value pairs as
 * connection arguments; normally at least a "user" and
 * "password" property should be included
 */
public JdbcMeta(String url, Properties info, MetricsSystem metrics)
    throws SQLException {
  this.url = url;
  this.info = info;
  this.metrics = Objects.requireNonNull(metrics);

  int concurrencyLevel = Integer.parseInt(
      info.getProperty(ConnectionCacheSettings.CONCURRENCY_LEVEL.key(),
          ConnectionCacheSettings.CONCURRENCY_LEVEL.defaultValue()));
  int initialCapacity = Integer.parseInt(
      info.getProperty(ConnectionCacheSettings.INITIAL_CAPACITY.key(),
          ConnectionCacheSettings.INITIAL_CAPACITY.defaultValue()));
  long maxCapacity = Long.parseLong(
      info.getProperty(ConnectionCacheSettings.MAX_CAPACITY.key(),
          ConnectionCacheSettings.MAX_CAPACITY.defaultValue()));
  long connectionExpiryDuration = Long.parseLong(
      info.getProperty(ConnectionCacheSettings.EXPIRY_DURATION.key(),
          ConnectionCacheSettings.EXPIRY_DURATION.defaultValue()));
  TimeUnit connectionExpiryUnit = TimeUnit.valueOf(
      info.getProperty(ConnectionCacheSettings.EXPIRY_UNIT.key(),
          ConnectionCacheSettings.EXPIRY_UNIT.defaultValue()));
  this.connectionCache = CacheBuilder.newBuilder()
      .concurrencyLevel(concurrencyLevel)
      .initialCapacity(initialCapacity)
      .maximumSize(maxCapacity)
      .expireAfterAccess(connectionExpiryDuration, connectionExpiryUnit)
      .removalListener(new ConnectionExpiryHandler())
      .build();
  LOG.debug("instantiated connection cache: {}", connectionCache.stats());

  concurrencyLevel = Integer.parseInt(
      info.getProperty(StatementCacheSettings.CONCURRENCY_LEVEL.key(),
          StatementCacheSettings.CONCURRENCY_LEVEL.defaultValue()));
  initialCapacity = Integer.parseInt(
      info.getProperty(StatementCacheSettings.INITIAL_CAPACITY.key(),
          StatementCacheSettings.INITIAL_CAPACITY.defaultValue()));
  maxCapacity = Long.parseLong(
      info.getProperty(StatementCacheSettings.MAX_CAPACITY.key(),
          StatementCacheSettings.MAX_CAPACITY.defaultValue()));
  connectionExpiryDuration = Long.parseLong(
      info.getProperty(StatementCacheSettings.EXPIRY_DURATION.key(),
          StatementCacheSettings.EXPIRY_DURATION.defaultValue()));
  connectionExpiryUnit = TimeUnit.valueOf(
      info.getProperty(StatementCacheSettings.EXPIRY_UNIT.key(),
          StatementCacheSettings.EXPIRY_UNIT.defaultValue()));
  this.statementCache = CacheBuilder.newBuilder()
      .concurrencyLevel(concurrencyLevel)
      .initialCapacity(initialCapacity)
      .maximumSize(maxCapacity)
      .expireAfterAccess(connectionExpiryDuration, connectionExpiryUnit)
      .removalListener(new StatementExpiryHandler())
      .build();

  LOG.debug("instantiated statement cache: {}", statementCache.stats());

  // Register some metrics
  this.metrics.register(concat(JdbcMeta.class, "ConnectionCacheSize"), new Gauge<Long>() {
    @Override public Long getValue() {
      return connectionCache.size();
    }
  });

  this.metrics.register(concat(JdbcMeta.class, "StatementCacheSize"), new Gauge<Long>() {
    @Override public Long getValue() {
      return statementCache.size();
    }
  });
}
 

/**
 * Creates a QuicksqlServerMeta.
 *
 * @param url a database url of the form
 * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
 * @param info a list of arbitrary string tag/value pairs as connection arguments; normally at least a "user" and
 * "password" property should be included
 */
public QuicksqlServerMeta(String url, Properties info, MetricsSystem metrics) throws SQLException {
    this.url = url;
    this.info = info;
    this.metrics = Objects.requireNonNull(metrics);

    int concurrencyLevel = Integer.parseInt(
        info.getProperty(ConnectionCacheSettings.CONCURRENCY_LEVEL.key(),
            ConnectionCacheSettings.CONCURRENCY_LEVEL.defaultValue()));
    int initialCapacity = Integer.parseInt(
        info.getProperty(ConnectionCacheSettings.INITIAL_CAPACITY.key(),
            ConnectionCacheSettings.INITIAL_CAPACITY.defaultValue()));
    long maxCapacity = Long.parseLong(
        info.getProperty(ConnectionCacheSettings.MAX_CAPACITY.key(),
            ConnectionCacheSettings.MAX_CAPACITY.defaultValue()));
    long connectionExpiryDuration = Long.parseLong(
        info.getProperty(ConnectionCacheSettings.EXPIRY_DURATION.key(),
            ConnectionCacheSettings.EXPIRY_DURATION.defaultValue()));
    TimeUnit connectionExpiryUnit = TimeUnit.valueOf(
        info.getProperty(ConnectionCacheSettings.EXPIRY_UNIT.key(),
            ConnectionCacheSettings.EXPIRY_UNIT.defaultValue()));
    this.connectionCache = CacheBuilder.newBuilder()
        .concurrencyLevel(concurrencyLevel)
        .initialCapacity(initialCapacity)
        .maximumSize(maxCapacity)
        .expireAfterAccess(connectionExpiryDuration, connectionExpiryUnit)
        .removalListener(new ConnectionExpiryHandler())
        .build();
    LOGGER.debug("instantiated connection cache: {}", connectionCache.stats());

    concurrencyLevel = Integer.parseInt(
        info.getProperty(StatementCacheSettings.CONCURRENCY_LEVEL.key(),
            StatementCacheSettings.CONCURRENCY_LEVEL.defaultValue()));
    initialCapacity = Integer.parseInt(
        info.getProperty(StatementCacheSettings.INITIAL_CAPACITY.key(),
            StatementCacheSettings.INITIAL_CAPACITY.defaultValue()));
    maxCapacity = Long.parseLong(
        info.getProperty(StatementCacheSettings.MAX_CAPACITY.key(),
            StatementCacheSettings.MAX_CAPACITY.defaultValue()));
    connectionExpiryDuration = Long.parseLong(
        info.getProperty(StatementCacheSettings.EXPIRY_DURATION.key(),
            StatementCacheSettings.EXPIRY_DURATION.defaultValue()));
    connectionExpiryUnit = TimeUnit.valueOf(
        info.getProperty(StatementCacheSettings.EXPIRY_UNIT.key(),
            StatementCacheSettings.EXPIRY_UNIT.defaultValue()));
    this.statementCache = CacheBuilder.newBuilder()
        .concurrencyLevel(concurrencyLevel)
        .initialCapacity(initialCapacity)
        .maximumSize(maxCapacity)
        .expireAfterAccess(connectionExpiryDuration, connectionExpiryUnit)
        .removalListener(new StatementExpiryHandler())
        .build();

    LOGGER.debug("instantiated statement cache: {}", statementCache.stats());

    // Register some metrics
    this.metrics.register(concat(
        QuicksqlServerMeta.class, "ConnectionCacheSize"), new Gauge<Long>() {
        @Override
        public Long getValue() {
            return connectionCache.size();
        }
    });

    this.metrics.register(concat(QuicksqlServerMeta.class, "StatementCacheSize"), new Gauge<Long>() {
        @Override
        public Long getValue() {
            return statementCache.size();
        }
    });
}
 

@Override
public MetricsSystem getMetrics() {
    return metrics;
}
 

/**
 * @return An instance of the {@link MetricsSystem} for this AvaticaHandler.
 */
MetricsSystem getMetrics();