NoopRegistry (Spectator)

java.lang.Object
- com.netflix.spectator.api.NoopRegistry

All Implemented Interfaces:

Registry, Iterable<Meter>
```
public final class NoopRegistry
extends Object
implements Registry
```
Registry implementation that does nothing. This is typically used to allow for performance tests to see how much overhead is being added by instrumentation. This implementation tries to do the minimum amount possible without requiring code changes for users.

Constructor Summary

Constructors
Constructor and Description

NoopRegistry()

Constructors
Constructor and Description
`NoopRegistry()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Clock`	`clock()` The clock used by the registry for timing events.
`Counter`	`counter(Id id)` Measures the rate of some activity.
`Id`	`createId(String name)` Creates an identifier for a meter.
`Id`	`createId(String name, Iterable<Tag> tags)` Creates an identifier for a meter.
`DistributionSummary`	`distributionSummary(Id id)` Measures the rate and variation in amount for some activity.
`Gauge`	`gauge(Id id)` Represents a value sampled from another source.
`Meter`	`get(Id id)` Returns the meter associated with a given id.
`Iterator<Meter>`	`iterator()` Iterator for traversing the set of meters in the registry.
`Gauge`	`maxGauge(Id id)` Measures the maximum value recorded since the last reset.
`void`	`propagate(String msg, Throwable t)` Log a warning and if enabled propagate the exception `t`.
`void`	`propagate(Throwable t)` Log a warning using the message from the exception and if enabled propagate the exception `t`.
`void`	`register(Meter meter)` Register a passive gauge.
`ConcurrentMap<Id,Object>`	`state()` Returns a map that can be used to associate state with the registry.
`Timer`	`timer(Id id)` Measures the rate and time taken for short running tasks.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.netflix.spectator.api.Registry
collectionSize, collectionSize, config, counter, counter, counter, counters, createId, createId, distributionSummaries, distributionSummary, distributionSummary, distributionSummary, gauge, gauge, gauge, gauge, gauge, gauge, gauge, gauge, gauges, longTaskTimer, longTaskTimer, longTaskTimer, longTaskTimer, mapSize, mapSize, maxGauge, maxGauge, maxGauge, measurements, methodValue, methodValue, stream, timer, timer, timer, timers, underlying

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - NoopRegistry
```
public NoopRegistry()
```
- Method Detail
  - clock
```
public Clock clock()
```
    Description copied from interface: Registry
    
    The clock used by the registry for timing events.
    
    Specified by:
    
    clock in interface Registry
  - createId
```
public Id createId(String name)
```
    Description copied from interface: Registry
    
    Creates an identifier for a meter. All ids passed into other calls should be created by the registry.
    
    Specified by:
    
    createId in interface Registry
    
    Parameters:
    
    name - Description of the measurement that is being collected.
  - createId
```
public Id createId(String name,
                   Iterable<Tag> tags)
```
    Description copied from interface: Registry
    
    Creates an identifier for a meter. All ids passed into other calls should be created by the registry.
    
    Specified by:
    
    createId in interface Registry
    
    Parameters:
    
    name - Description of the measurement that is being collected.
    
    tags - Other dimensions that can be used to classify the measurement.
  - register
```
public void register(Meter meter)
```
    Description copied from interface: Registry
    
    Register a passive gauge. In most cases users should not use this method directly. Use one of the helper methods for working with gauges.
    
    Specified by:
    
    register in interface Registry
    
    See Also:
    
    Registry.gauge(Id, Number), Registry.gauge(Id, Object, ToDoubleFunction), Registry.collectionSize(Id, Collection), Registry.mapSize(Id, Map)
  - state
```
public ConcurrentMap<Id,Object> state()
```
    Description copied from interface: Registry
    
    Returns a map that can be used to associate state with the registry. Users instrumenting their application will most likely never need to use this method. The primary use case is for building custom meter types that need some additional state beyond the core types supported by the registry. This map can be used to store the state so that the lifecycle of the data is connected to the registry. For an example, see some of the built in patterns such as LongTaskTimer.
    
    Specified by:
    
    state in interface Registry
  - counter
```
public Counter counter(Id id)
```
    Description copied from interface: Registry
    
    Measures the rate of some activity. A counter is for continuously incrementing sources like the number of requests that are coming into a server.
    
    Specified by:
    
    counter in interface Registry
    
    Parameters:
    
    id - Identifier created by a call to Registry.createId(java.lang.String)
  - distributionSummary
```
public DistributionSummary distributionSummary(Id id)
```
    Description copied from interface: Registry
    
    Measures the rate and variation in amount for some activity. For example, it could be used to get insight into the variation in response sizes for requests to a server.
    
    Specified by:
    
    distributionSummary in interface Registry
    
    Parameters:
    
    id - Identifier created by a call to Registry.createId(java.lang.String)
  - timer
```
public Timer timer(Id id)
```
    Description copied from interface: Registry
    
    Measures the rate and time taken for short running tasks.
    
    Specified by:
    
    timer in interface Registry
    
    Parameters:
    
    id - Identifier created by a call to Registry.createId(java.lang.String)
  - gauge
```
public Gauge gauge(Id id)
```
    Description copied from interface: Registry
    
    Represents a value sampled from another source. For example, the size of queue. The caller is responsible for sampling the value regularly and calling Gauge.set(double). Registry implementations are free to expire the gauge if it has not been updated in the last minute. If you do not want to worry about the sampling, then use PolledMeter instead.
    
    Specified by:
    
    gauge in interface Registry
    
    Parameters:
    
    id - Identifier created by a call to Registry.createId(java.lang.String)
  - maxGauge
```
public Gauge maxGauge(Id id)
```
    Description copied from interface: Registry
    
    Measures the maximum value recorded since the last reset. For example, to measure the maximum number of concurrent requests to a service. In many cases it is better to use a Registry.distributionSummary(Id) which provides a max along with other stats for most registry implementations.
    
    Specified by:
    
    maxGauge in interface Registry
    
    Parameters:
    
    id - Identifier created by a call to Registry.createId(java.lang.String)
  - get
```
public Meter get(Id id)
```
    Description copied from interface: Registry
    
    Returns the meter associated with a given id.
    
    Specified by:
    
    get in interface Registry
    
    Parameters:
    
    id - Identifier for the meter.
    
    Returns:
    
    Instance of the meter or null if there is no match.
  - iterator
```
public Iterator<Meter> iterator()
```
    Description copied from interface: Registry
    
    Iterator for traversing the set of meters in the registry.
    
    Specified by:
    
    iterator in interface Registry
    
    Specified by:
    
    iterator in interface Iterable<Meter>
  - propagate
```
public void propagate(String msg,
                      Throwable t)
```
    Description copied from interface: Registry
    
    Log a warning and if enabled propagate the exception t. As a general rule instrumentation code should degrade gracefully and avoid impacting the core application. If the user makes a mistake and causes something to break, then it should not impact the application unless that mistake triggers a problem outside of the instrumentation code. However, in test code it is often better to throw so that mistakes are caught and corrected. This method is used to handle exceptions internal to the instrumentation code. Propagation is controlled by the RegistryConfig.propagateWarnings() setting. If the setting is true, then the exception will be propagated. Otherwise the exception will only get logged as a warning.
    
    Specified by:
    
    propagate in interface Registry
    
    Parameters:
    
    msg - Message written out to the log.
    
    t - Exception to log and optionally propagate.
  - propagate
```
public void propagate(Throwable t)
```
    Description copied from interface: Registry
    
    Log a warning using the message from the exception and if enabled propagate the exception t. For more information see Registry.propagate(String, Throwable).
    
    Specified by:
    
    propagate in interface Registry
    
    Parameters:
    
    t - Exception to log and optionally propagate.

Class NoopRegistry

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.netflix.spectator.api.Registry

Methods inherited from interface java.lang.Iterable

Constructor Detail

NoopRegistry

Method Detail

clock

createId

createId

register

state

counter

distributionSummary

timer

gauge

maxGauge

get

iterator

propagate

propagate