com.codahale.metrics.SharedMetricRegistries.names java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 BufferedReader b =InputStream in;new BufferedReader(new InputStreamReader(in))
Reader in;new BufferedReader(in)
File file;new BufferedReader(new FileReader(file))
Smart code suggestions by Tabnine
}

  @Test
  public void metricMethodsWithDefaultNamingConvention() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Metrics are not registered correctly", registry.getMetrics().keySet(), is(equalTo(metricNames())));
  }
}

  @Test
  public void callGaugeAfterSetterCall() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Gauge is not registered correctly", registry.getGauges(), hasKey(GAUGE_NAME));
    @SuppressWarnings("unchecked")
    Gauge<Long> gauge = registry.getGauges().get(GAUGE_NAME);

    // Call the setter method and assert the gauge is up-to-date
    long value = Math.round(Math.random() * Long.MAX_VALUE);
    instance.setSingleGauge(value);
    assertThat("Gauge value is incorrect", gauge.getValue(), is(equalTo(value)));
  }
}

  @Test
  public void callStaticGaugeAfterSetterCall() {
    long value = Math.round(Math.random() * Long.MAX_VALUE);
    // Call the setter static method and assert the gauge is up-to-date
    GaugeStaticMethodWithRegistryFromString.setSingleGauge(value);

    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Gauge is not registered correctly", registry.getGauges(), hasKey(GAUGE_NAME));
    @SuppressWarnings("unchecked")
    Gauge<Long> gauge = registry.getGauges().get(GAUGE_NAME);
    assertThat("Gauge value is incorrect", gauge.getValue(), is(equalTo(value)));
  }
}

@Test
public void gaugeCalledWithDefaultValue() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Gauge is not registered correctly", registry.getGauges(), hasKey(GAUGE_NAME));
  @SuppressWarnings("unchecked")
  Gauge<Long> gauge = registry.getGauges().get(GAUGE_NAME);
  // Make sure that the gauge has the expected value
  assertThat("Gauge value is incorrect", gauge.getValue(), is(equalTo(0L)));
}

@Test
public void exceptionMeteredMethodsNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Meters are not registered correctly", registry.getMeters().keySet(), is(equalTo(absoluteMetricNames())));
  // Make sure that all the meters haven't been called yet
  assertThat("Meter counts are incorrect", registry.getMeters().values(), everyItem(Matchers.<Meter>hasProperty("count", equalTo(0L))));
}

@Test
public void overloadedTimedMethodNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Timers are not registered correctly", registry.getTimers().keySet(), is(equalTo(absoluteMetricNames())));
  // Make sure that all the timers haven't been called yet
  assertThat("Timer counts are incorrect", registry.getTimers().values(), everyItem(Matchers.<Timer>hasProperty("count", equalTo(0L))));
}

@Test
public void gaugesCalledWithDefaultValues() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Gauges are not registered correctly", registry.getGauges().keySet(), is(equalTo(absoluteMetricNames())));
  // Make sure that the gauges have the expected values
  assertThat("Gauge values are incorrect", registry.getGauges().values(), everyItem(Matchers.<Gauge>hasProperty("value", equalTo(0L))));
}

@Test
public void timedMethodsNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Timers are not registered correctly", registry.getTimers().keySet(), is(equalTo(absoluteMetricNames())));
  // Make sure that all the timers haven't been called yet
  assertThat("Timer counts are incorrect", registry.getTimers().values(), everyItem(Matchers.<Timer>hasProperty("count", equalTo(0L))));
}

@Test
public void timedMethodsNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Timers are not registered correctly", registry.getTimers().keySet(), is(equalTo(absoluteMetricNames())));
  // Make sure that all the timers haven't been called yet
  assertThat("Timer counts are incorrect", registry.getTimers().values(), everyItem(Matchers.<Timer>hasProperty("count", equalTo(0L))));
}

@Test
public void metricsMethodNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Metrics are not registered correctly", registry.getMetrics().keySet(), is(equalTo(absoluteMetricNames())));
  // Make sure that the metrics haven't been called yet
  assertThat("Meter count is incorrect", registry.getMeters().get(absoluteMetricName("exception")).getCount(), is(equalTo(0L)));
  assertThat("Meter count is incorrect", registry.getMeters().get(absoluteMetricName("meter")).getCount(), is(equalTo(0L)));
  assertThat("Timer count is incorrect", registry.getTimers().get(absoluteMetricName("timer")).getCount(), is(equalTo(0L)));
}

@Test
public void timedMethodNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Timer is not registered correctly", registry.getTimers(), hasKey(TIMER_NAME));
  Timer timer = registry.getTimers().get(TIMER_NAME);
  // Make sure that the timer hasn't been called yet
  assertThat("Timer count is incorrect", timer.getCount(), is(equalTo(0L)));
}

@Test
public void timedMethodNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Timer is not registered correctly", registry.getTimers(), hasKey(TIMER_NAME));
  Timer timer = registry.getTimers().get(TIMER_NAME);
  // Make sure that the timer hasn't been called yet
  assertThat("Timer count is incorrect", timer.getCount(), is(equalTo(0L)));
}

@Test
public void meteredMethodNotCalledYet() {
  assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
  assertThat("Meter is not registered correctly", registry.getMeters(), hasKey(METER_NAME));
  Meter meter = registry.getMeters().get(METER_NAME);
  // Make sure that the meter hasn't been called yet
  assertThat("Meter count is incorrect", meter.getCount(), is(equalTo(0L)));
}

  @Test
  public void callOverloadedTimedMethodOnce() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Timers are not registered correctly", registry.getTimers().keySet(), is(equalTo(absoluteMetricNames())));

    // Call the timed methods and assert they've all been timed once
    instance.overloadedTimedMethod();
    instance.overloadedTimedMethod("string");
    instance.overloadedTimedMethod(new Object());
    instance.overloadedTimedMethod(Arrays.asList("string1", "string2"));
    assertThat("Timer counts are incorrect", registry.getTimers().values(), everyItem(Matchers.<Timer>hasProperty("count", equalTo(1L))));
  }
}

  @Test
  public void callMeteredMethodOnce() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Meter is not registered correctly", registry.getMeters(), hasKey(METER_NAME));
    Meter meter = registry.getMeters().get(METER_NAME);

    // Call the metered method and assert it's been marked
    instance.singleMeteredMethod();
    assertThat("Meter count is incorrect", meter.getCount(), is(equalTo(1L)));
  }
}

  @Test
  public void callTimedMethodOnce() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Timer is not registered correctly", registry.getTimers(), hasKey(TIMER_NAME));
    Timer timer = registry.getTimers().get(TIMER_NAME);

    // Call the timed method and assert it's been timed
    instance.absoluteTimedMethod();
    assertThat("Timer count is incorrect", timer.getCount(), is(equalTo(1L)));
  }
}

  @Test
  public void callTimedMethodOnce() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Timer is not registered correctly", registry.getTimers(), hasKey(TIMER_NAME));
    Timer timer = registry.getTimers().get(TIMER_NAME);

    // Call the timed method and assert it's been timed
    instance.singleTimedMethod();
    assertThat("Timer count is incorrect", timer.getCount(), is(equalTo(1L)));
  }
}

  @Test
  public void callMeteredStaticMethodOnce() {
    // Call the metered method and assert it's been marked
    MeteredStaticMethodWithRegistryFromString.singleMeteredStaticMethod();

    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Timer is not registered correctly", registry.getMeters(), hasKey(METER_NAME));
    Meter meter = registry.getMeters().get(METER_NAME);
    assertThat("Meter count is incorrect", meter.getCount(), is(equalTo(1L)));
  }
}

  @Test
  public void callTimedStaticMethodsOnce() {
    // Call the timed methods and assert they've all been timed once
    TimedStaticMethodWithVisibilityModifiers.publicTimedStaticMethod();
    TimedStaticMethodWithVisibilityModifiers.protectedTimedStaticMethod();
    TimedStaticMethodWithVisibilityModifiers.packagePrivateTimedStaticMethod();
    staticMethod("privateTimedStaticMethod").in(TimedStaticMethodWithVisibilityModifiers.class).invoke();

    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);

    assertThat("Timers are not registered correctly", registry.getTimers().keySet(), is(equalTo(absoluteMetricNames())));

    assertThat("Timer counts are incorrect", registry.getTimers().values(), everyItem(Matchers.<Timer>hasProperty("count", equalTo(1L))));
  }
}

  @Test
  public void callTimedMethodsOnce() {
    assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME));
    MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME);
    assertThat("Timers are not registered correctly", registry.getTimers().keySet(), is(equalTo(absoluteMetricNames())));

    // Call the timed methods and assert they've all been timed once
    instance.publicTimedMethod();
    instance.protectedTimedMethod();
    instance.packagePrivateTimedMethod();
    method("privateTimedMethod").in(instance).invoke();
    assertThat("Timer counts are incorrect", registry.getTimers().values(), everyItem(Matchers.<Timer>hasProperty("count", equalTo(1L))));
  }
}

Popular methods of SharedMetricRegistries

getOrCreate
add
clear
setDefault
Sets the provided registry as the default one under the provided name
tryGetDefault
Same as #getDefault() except returns null when the default registry has not been set.
getDefault
Gets the name of the default registry, if it has been set
remove

Popular in Java

Parsing JSON documents to java classes using gson
getSharedPreferences (Context)
setScale (BigDecimal)
startActivity (Activity)
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
BitSet (java.util)
The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
Deque (java.util)
A linear collection that supports element insertion and removal at both ends. The name deque is shor
LinkedHashMap (java.util)
LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
Handler (java.util.logging)
A Handler object accepts a logging request and exports the desired messages to a target, for example
ImageIO (javax.imageio)
Top plugins for WebStorm

How to use namesmethodin com.codahale.metrics.SharedMetricRegistries

Best Java code snippets using com.codahale.metrics.SharedMetricRegistries.names (Showing top 20 results out of 315)

How to use
names
method
in
com.codahale.metrics.SharedMetricRegistries