コード例 #1
0
  @After
  public void tearDown() {
    reporter.stop();
    reporter.report();

    executor.shutdownNow();
  }
 private void test(DataSource dataSource) throws SQLException {
   for (int i = 0; i < callCount; i++) {
     long startNanos = System.nanoTime();
     try (Connection connection = dataSource.getConnection()) {}
     timer.update(System.nanoTime() - startNanos, TimeUnit.NANOSECONDS);
   }
   logReporter.report();
 }
コード例 #3
0
ファイル: Application.java プロジェクト: sammycabrera/camel-1
 @Produces
 @Singleton
 Slf4jReporter reporter(MetricRegistry registry) {
   return Slf4jReporter.forRegistry(registry)
       .convertRatesTo(TimeUnit.SECONDS)
       .convertDurationsTo(TimeUnit.MILLISECONDS)
       .build();
 }
/**
 * <code>ConnectionPoolCallTest</code> - Checks how connection pool decreases latency
 *
 * @author Vlad Mihalcea
 */
@Ignore
public class ConnectionPoolCallTest extends DataSourceProviderIntegrationTest {

  private final Logger LOGGER = LoggerFactory.getLogger(getClass());

  private MetricRegistry metricRegistry = new MetricRegistry();

  private Timer timer = metricRegistry.timer("callTimer");

  private Slf4jReporter logReporter =
      Slf4jReporter.forRegistry(metricRegistry).outputTo(LOGGER).build();

  private int callCount = 1000;

  public ConnectionPoolCallTest(DataSourceProvider dataSourceProvider) {
    super(dataSourceProvider);
  }

  @Override
  protected Class<?>[] entities() {
    return new Class[] {};
  }

  @Test
  public void testNoPooling() throws SQLException {
    LOGGER.info("Test without pooling for {}", dataSourceProvider().database());
    test(dataSourceProvider().dataSource());
  }

  @Test
  public void testPooling() throws SQLException {
    LOGGER.info("Test with pooling for {}", dataSourceProvider().database());
    test(poolingDataSource());
  }

  private void test(DataSource dataSource) throws SQLException {
    for (int i = 0; i < callCount; i++) {
      long startNanos = System.nanoTime();
      try (Connection connection = dataSource.getConnection()) {}
      timer.update(System.nanoTime() - startNanos, TimeUnit.NANOSECONDS);
    }
    logReporter.report();
  }

  protected HikariDataSource poolingDataSource() {
    Properties properties = new Properties();
    properties.setProperty(
        "dataSourceClassName", dataSourceProvider().dataSourceClassName().getName());
    properties.put("dataSourceProperties", dataSourceProvider().dataSourceProperties());
    properties.setProperty("minimumPoolSize", String.valueOf(1));
    properties.setProperty("maximumPoolSize", String.valueOf(3));
    properties.setProperty("connectionTimeout", String.valueOf(100));
    return new HikariDataSource(new HikariConfig(properties));
  }
}
コード例 #5
0
  @Before
  public void setupOrg() {

    originalShardSize = ConfigurationManager.getConfigInstance().getProperty(GraphFig.SHARD_SIZE);

    originalShardTimeout =
        ConfigurationManager.getConfigInstance().getProperty(GraphFig.SHARD_CACHE_TIMEOUT);

    originalShardDelta =
        ConfigurationManager.getConfigInstance().getProperty(GraphFig.SHARD_MIN_DELTA);

    ConfigurationManager.getConfigInstance().setProperty(GraphFig.SHARD_SIZE, 500);

    final long cacheTimeout = 2000;
    // set our cache timeout to the above value
    ConfigurationManager.getConfigInstance()
        .setProperty(GraphFig.SHARD_CACHE_TIMEOUT, cacheTimeout);

    final long minDelta = (long) (cacheTimeout * 2.5);

    ConfigurationManager.getConfigInstance().setProperty(GraphFig.SHARD_MIN_DELTA, minDelta);

    // get the system property of the UUID to use.  If one is not set, use the defualt
    String uuidString = System.getProperty("org.id", "80a42760-b699-11e3-a5e2-0800200c9a66");

    scope = new ApplicationScopeImpl(IdGenerator.createId(UUID.fromString(uuidString), "test"));

    reporter =
        Slf4jReporter.forRegistry(registry)
            .outputTo(logger)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();

    reporter.start(10, TimeUnit.SECONDS);
  }
 static {
   logReporter.start(30, TimeUnit.SECONDS);
 }
/**
 * ConnectionProxyFactoryPerformanceTest - ConnectionProxyFactory Performance Test
 *
 * @author Vlad Mihalcea
 */
public class ConnectionProxyFactoryPerformanceTest extends ConnectionDecoratorTest {

  private static final Logger LOGGER =
      LoggerFactory.getLogger(ConnectionProxyFactoryPerformanceTest.class);

  private static MetricRegistry metricRegistry = new MetricRegistry();

  private static Slf4jReporter logReporter =
      Slf4jReporter.forRegistry(metricRegistry).outputTo(LOGGER).build();

  private static Timer noProxyHistogram = metricRegistry.timer("no-proxy");
  private static Timer proxyHistogram = metricRegistry.timer("proxy");

  static {
    logReporter.start(30, TimeUnit.SECONDS);
  }

  private final Connection targetConnection = Mockito.mock(Connection.class);
  private final ConnectionCallback connectionCallback = Mockito.mock(ConnectionCallback.class);

  private final InvocationHandler invocationHandler =
      new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          return method.invoke(targetConnection, args);
        }
      };
  private final Connection proxy =
      (Connection)
          Proxy.newProxyInstance(
              this.getClass().getClassLoader(), new Class[] {Connection.class}, invocationHandler);

  private ConnectionDecorator connectionDecorator =
      new ConnectionDecorator(targetConnection, connectionCallback);

  @Test
  public void testPerformance() {
    if (TestUtils.isPerformanceTesting()) {
      long durationMillis = 30 * 1000;
      timeAllMethodsForDuration(
          new Callable() {
            @Override
            public Object call() throws Exception {
              callConnectionMethods(noProxyHistogram);
              return null;
            }
          },
          durationMillis);
      timeAllMethodsForDuration(
          new Callable() {
            @Override
            public Object call() throws Exception {
              callConnectionMethods(proxyHistogram);
              return null;
            }
          },
          durationMillis);
    }
  }

  private void callConnectionMethods(Timer timer) throws SQLException {
    long startNanos = System.nanoTime();
    try {
      connectionDecorator.getMetaData();
      String javaVersion = System.getProperty("java.version");
      if (javaVersion.contains("1.7") || javaVersion.contains("1.8")) {
        connectionDecorator.setSchema("schema");
        connectionDecorator.abort(null);
      }
    } finally {
      long endNanos = System.nanoTime();
      timer.update((endNanos - startNanos), TimeUnit.NANOSECONDS);
    }
  }

  private void timeAllMethodsForDuration(Callable callable, long durationMillis) {
    long startMillis = System.currentTimeMillis();
    int i = 0;
    while (true) {
      long endMillis = System.currentTimeMillis();
      if (i % 1000 == 0) {
        LOGGER.info("Iteration: {}, total millis {}!", i, endMillis - startMillis);
        if ((endMillis - startMillis) > durationMillis) {
          break;
        }
      }
      try {
        callable.call();
      } catch (Exception e) {
        throw new IllegalArgumentException(e);
      }
      i++;
    }
  }
}
コード例 #8
0
ファイル: Application.java プロジェクト: sammycabrera/camel-1
 void onStop(@Disposes Slf4jReporter reporter) {
   reporter.stop();
 }
コード例 #9
0
ファイル: Application.java プロジェクト: sammycabrera/camel-1
 void onStart(@Observes CamelContextStartedEvent event, Slf4jReporter reporter) {
   reporter.start(10L, TimeUnit.SECONDS);
 }