org.glassfish.jersey.server.internal.monitoring

Class AggregatingTrimmer

java.lang.Object

org.glassfish.jersey.server.internal.monitoring.AggregatingTrimmer

All Implemented Interfaces:

SlidingWindowTrimmer<java.lang.Long>

class AggregatingTrimmer
extends java.lang.Object
implements SlidingWindowTrimmer<java.lang.Long>

An aggregating trimmer for sliding window measurements. This trimmer updates registered time reservoirs with the aggregated measurements for the values it trimmed.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.List<TimeReservoir<AggregatedValueObject>>	aggregatedReservoirListeners
private long	chunkSize
private java.util.concurrent.atomic.AtomicBoolean	locked The lock that prevents other threads to trim the associated reservoir in parallel.
private long	startTime
private java.util.concurrent.TimeUnit	startUnitTime
private TimeReservoir<java.lang.Long>	timeReservoirNotifier

Constructor Summary

Constructors

Constructor and Description
AggregatingTrimmer(long startTime, java.util.concurrent.TimeUnit startUnitTime, long chunkTimeSize, java.util.concurrent.TimeUnit chunkTimeSizeUnit) Creates the trimmer that updates the registered time reservoirs with the aggregated measurements for the values it trimmed.

Method Summary

Modifier and Type	Method and Description
TimeReservoir<java.lang.Long>	getTimeReservoirNotifier()
private long	lowerBound(java.lang.Long key)
(package private) static long	lowerBound(long key, long startTime, long chunkSize, int power) Calculates lower bound for given key so that following conditions are true
void	register(TimeReservoir<AggregatedValueObject> timeReservoirListener) Registers given aggregating sliding window reservoir to get updates from this trimmer.
void	setTimeReservoir(TimeReservoir<java.lang.Long> timeReservoirNotifier)
void	trim(java.util.concurrent.ConcurrentNavigableMap<java.lang.Long,java.lang.Long> map, long key) Trim the measurements provided as the map from the head up to the key (not inclusive).
private long	upperBound(long chunkLowerBound, long key)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

aggregatedReservoirListeners

private final java.util.List<TimeReservoir<AggregatedValueObject>> aggregatedReservoirListeners

timeReservoirNotifier

private TimeReservoir<java.lang.Long> timeReservoirNotifier

startTime

private final long startTime

startUnitTime

private final java.util.concurrent.TimeUnit startUnitTime

chunkSize

private final long chunkSize

locked

private final java.util.concurrent.atomic.AtomicBoolean locked

The lock that prevents other threads to trim the associated reservoir in parallel.

Constructor Detail

AggregatingTrimmer

public AggregatingTrimmer(long startTime,
                          java.util.concurrent.TimeUnit startUnitTime,
                          long chunkTimeSize,
                          java.util.concurrent.TimeUnit chunkTimeSizeUnit)

Creates the trimmer that updates the registered time reservoirs with the aggregated measurements for the values it trimmed.

Parameters:

startTime - The start time that determines the offset for the chunks.

startUnitTime - The time unit of the start time.

chunkTimeSize - The size of one "time chunk".

chunkTimeSizeUnit - The time unit of the time chunk.

Method Detail

trim

public void trim(java.util.concurrent.ConcurrentNavigableMap<java.lang.Long,java.lang.Long> map,
                 long key)

Description copied from interface: SlidingWindowTrimmer

Trim the measurements provided as the map from the head up to the key (not inclusive).

Specified by:

trim in interface SlidingWindowTrimmer<java.lang.Long>

Parameters:

map - The map to trim.

key - The key to which trim the map.

upperBound

private long upperBound(long chunkLowerBound,
                        long key)

lowerBound

private long lowerBound(java.lang.Long key)

lowerBound

static long lowerBound(long key,
                       long startTime,
                       long chunkSize,
                       int power)

Calculates lower bound for given key so that following conditions are true

     
 lowerBound <= key && key < lowerBound + chunkSize
     
The lower bound is a multiple of chunk size with an offset calculated as  (startTime % chunkSize) <<
 power
 

Note the offset calculation is determined by start time because not always one lower bound from the sequence of all lower bounds for given arguments is equal to 0.
The power is used to shift the offset because all the keys are also expected to be shifted with the power.

Parameters:

key - The key to find the lower bound for.

startTime - The start time that determines the offset for the chunks.

chunkSize - The size of one chunk.

power - The power the keys are expected to be shifted with.

Returns:

The lower bound for given arguments satisfying conditions stated above.

register

public void register(TimeReservoir<AggregatedValueObject> timeReservoirListener)

Registers given aggregating sliding window reservoir to get updates from this trimmer.

Parameters:

timeReservoirListener - The aggregated sliding window reservoir to update with trimmed measurements

setTimeReservoir

public void setTimeReservoir(TimeReservoir<java.lang.Long> timeReservoirNotifier)

Specified by:

setTimeReservoir in interface SlidingWindowTrimmer<java.lang.Long>

Parameters:

timeReservoirNotifier - The reservoir that uses this trimmer.

getTimeReservoirNotifier

public TimeReservoir<java.lang.Long> getTimeReservoirNotifier()

Returns:

The reservoir that produces the data this trimmer aggregates and trims.