com.unboundid.ldap.sdk.unboundidds.monitors.FIFOEntryCacheMonitorEntry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of unboundid-ldapsdk Show documentation
Show all versions of unboundid-ldapsdk Show documentation
The UnboundID LDAP SDK for Java is a fast, comprehensive, and easy-to-use
Java API for communicating with LDAP directory servers and performing
related tasks like reading and writing LDIF, encoding and decoding data
using base64 and ASN.1 BER, and performing secure communication. This
package contains the Standard Edition of the LDAP SDK, which is a
complete, general-purpose library for communicating with LDAPv3 directory
servers.
/*
* Copyright 2011-2018 Ping Identity Corporation
* All Rights Reserved.
*/
/*
* Copyright (C) 2015-2018 Ping Identity Corporation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License (GPLv2 only)
* or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see .
*/
package com.unboundid.ldap.sdk.unboundidds.monitors;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.util.NotMutable;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.ThreadSafety;
import com.unboundid.util.ThreadSafetyLevel;
import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
/**
* This class defines a monitor entry that provides information about the sate
* of a FIFO entry cache in the Directory Server.
*
*
* NOTE: This class, and other classes within the
* {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
* supported for use against Ping Identity, UnboundID, and
* Nokia/Alcatel-Lucent 8661 server products. These classes provide support
* for proprietary functionality or for external specifications that are not
* considered stable or mature enough to be guaranteed to work in an
* interoperable way with other types of LDAP servers.
*
*
* The information that may be available about the entry cache includes:
*
* - The name assigned to the cache.
* - The number of attempts (successful and total) and the hit ratio when
* trying to retrieve an entry from the cache.
* - The maximum allowed size of the entry cache in entries and bytes.
* - The number of entries currently held in the cache.
* - The number of entries added to or updated in the cache.
* - The number of times an entry was not added to the cache because it was
* already present.
* - The number of times an entry was not added to the cache because it did
* not match filter criteria required for inclusion.
* - The number of times an entry was not added to the cache because it was
* too small to be included.
* - The number of times an entry was evicted because of memory pressure or
* to make room for new entries.
* - Information about the current memory consumption of the cache and
* whether the cache is currently full.
*
* The server will automatically present one monitor entry for every FIFO entry
* cache defined in the server. It is possible to have multiple caches enabled
* if desired (e.g., one specifically targeting large static groups, and another
* small cache to help improve write-after-read performance). FIFO entry cache
* monitor entries can be retrieved using the
* {@link MonitorManager#getFIFOEntryCacheMonitorEntries} method. These monitor
* entries provide specific methods for accessing information about the FIFO
* entry cache. Alternately, this information may be accessed using the generic
* API. See the {@link MonitorManager} class documentation for an example that
* demonstrates the use of the generic API for accessing monitor data.
*/
@NotMutable()
@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
public final class FIFOEntryCacheMonitorEntry
extends MonitorEntry
{
/**
* The structural object class used in entry cache monitor entries.
*/
static final String FIFO_ENTRY_CACHE_MONITOR_OC =
"ds-fifo-entry-cache-monitor-entry";
/**
* The name of the attribute that holds the name of the associated FIFO entry
* cache.
*/
private static final String ATTR_CACHE_NAME = "cacheName";
/**
* The name of the attribute that holds the number of cache hits.
*/
private static final String ATTR_ENTRY_CACHE_HITS = "entryCacheHits";
/**
* The name of the attribute that holds the number of cache tries.
*/
private static final String ATTR_ENTRY_CACHE_TRIES = "entryCacheTries";
/**
* The name of the attribute that holds the cache hit ratio.
*/
private static final String ATTR_ENTRY_CACHE_HIT_RATIO = "entryCacheHitRatio";
/**
* The name of the attribute that holds the maximum cache size in bytes.
*/
private static final String ATTR_MAX_ENTRY_CACHE_SIZE = "maxEntryCacheSize";
/**
* The name of the attribute that holds the number of entries currently in the
* cache.
*/
private static final String ATTR_CURRENT_ENTRY_CACHE_COUNT =
"currentEntryCacheCount";
/**
* The name of the attribute that holds the maximum number of entries that may
* be held in the cache.
*/
private static final String ATTR_MAX_ENTRY_CACHE_COUNT = "maxEntryCacheCount";
/**
* The name of the attribute that holds the number of entries added to or
* replaced in the cache.
*/
private static final String ATTR_ENTRIES_ADDED_OR_UPDATED =
"entriesAddedOrUpdated";
/**
* The name of the attribute that holds the number of entries evicted because
* the entry cache had reached its maximum memory allocation.
*/
private static final String ATTR_EVICTIONS_DUE_TO_MAX_MEMORY =
"evictionsDueToMaxMemory";
/**
* The name of the attribute that holds the number of entries evicted because
* the entry cache had reached its maximum entry count.
*/
private static final String ATTR_EVICTIONS_DUE_TO_MAX_ENTRIES =
"evictionsDueToMaxEntries";
/**
* The name of the attribute that holds the number of entries that were not
* added because they were already present in the cache.
*/
private static final String ATTR_ENTRIES_NOT_ADDED_ALREADY_PRESENT =
"entriesNotAddedAlreadyPresent";
/**
* The name of the attribute that holds the number of entries that were not
* added because the cache had reached its maximum memory allocation.
*/
private static final String ATTR_ENTRIES_NOT_ADDED_DUE_TO_MAX_MEMORY =
"entriesNotAddedDueToMaxMemory";
/**
* The name of the attribute that holds the number of entries that were not
* added because they did not meet the necessary filter criteria.
*/
private static final String ATTR_ENTRIES_NOT_ADDED_DUE_TO_FILTER =
"entriesNotAddedDueToFilter";
/**
* The name of the attribute that holds the number of entries that were not
* added because they did not have enough values to be considered for
* inclusion in the cache.
*/
private static final String ATTR_ENTRIES_NOT_ADDED_DUE_TO_ENTRY_SMALLNESS =
"entriesNotAddedDueToEntrySmallness";
/**
* The name of the attribute that holds the number of times that entries were
* purged from the cache because the JVM was running low on memory.
*/
private static final String ATTR_LOW_MEMORY_OCCURRENCES =
"lowMemoryOccurrences";
/**
* The name of the attribute that holds the percentage of the maximum allowed
* number of entries that are currently held in the cache.
*/
private static final String ATTR_PERCENT_FULL_MAX_ENTRIES =
"percentFullMaxEntries";
/**
* The name of the attribute that holds the maximum percent of JVM memory that
* may be consumed before entries may stop being added to the cache.
*/
private static final String ATTR_JVM_MEMORY_MAX_PERCENT_THRESHOLD =
"jvmMemoryMaxPercentThreshold";
/**
* The name of the attribute that holds the percent of JVM memory that is
* currently consumed.
*/
private static final String ATTR_JVM_MEMORY_CURRENT_PERCENT_FULL =
"jvmMemoryCurrentPercentFull";
/**
* The name of the attribute that holds the difference between the maximum
* memory percent threshold and the current percent full.
*/
private static final String ATTR_JVM_MEMORY_BELOW_MAX_MEMORY_PERCENT =
"jvmMemoryBelowMaxMemoryPercent";
/**
* The name of the attribute that indicates whether the entry cache is
* currently full (based on memory usage or number of entries).
*/
private static final String ATTR_IS_FULL = "isFull";
/**
* The name of the attribute that holds a human-readable message about the
* capacity and utilization of the cache.
*/
private static final String ATTR_CAPACITY_DETAILS = "capacityDetails";
/**
* The serial version UID for this serializable class.
*/
private static final long serialVersionUID = -3340643698412829407L;
// The value of the isFull attribute.
private final Boolean isFull;
// The value of the currentEntryCacheCount attribute.
private final Long currentEntryCacheCount;
// The value of the entriesAddedOrUpdated attribute.
private final Long entriesAddedOrUpdated;
// The value of the entriesNotAddedAlreadyPresent attribute.
private final Long entriesNotAddedAlreadyPresent;
// The value of the entriesNotAddedDueToEntrySmallness attribute.
private final Long entriesNotAddedDueToEntrySmallness;
// The value of the entriesNotAddedDueToFilter attribute.
private final Long entriesNotAddedDueToFilter;
// The value of the entriesNotAddedDueToMaxMemory attribute.
private final Long entriesNotAddedDueToMaxMemory;
// The value of the entryCacheHitRatio attribute.
private final Long entryCacheHitRatio;
// The value of the entryCacheHits attribute.
private final Long entryCacheHits;
// The value of the entryCacheTries attribute.
private final Long entryCacheTries;
// The value of the evictionsDueToMaxEntries attribute.
private final Long evictionsDueToMaxEntries;
// The value of the evictionsDueToMaxMemory attribute.
private final Long evictionsDueToMaxMemory;
// The value of the jvmMemoryBelowMaxMemoryPercent attribute.
private final Long jvmMemoryBelowMaxMemoryPercent;
// The value of the jvmMemoryCurrentPercentFull attribute.
private final Long jvmMemoryCurrentPercentFull;
// The value of the jvmMemoryMaxPercentThreshold attribute.
private final Long jvmMemoryMaxPercentThreshold;
// The value of the lowMemoryOccurrences attribute.
private final Long lowMemoryOccurrences;
// The value of the maxEntryCacheCount attribute.
private final Long maxEntryCacheCount;
// The value of the maxEntryCacheSize attribute.
private final Long maxEntryCacheSize;
// The value of the percentFullMaxEntries attribute.
private final Long percentFullMaxEntries;
// The value of the cacheName attribute.
private final String cacheName;
// The value of the capacityDetails attribute.
private final String capacityDetails;
/**
* Creates a new FIFO entry cache monitor entry from the provided entry.
*
* @param entry The entry to be parsed as a FIFO entry cache monitor entry.
* It must not be {@code null}.
*/
public FIFOEntryCacheMonitorEntry(final Entry entry)
{
super(entry);
isFull = getBoolean(ATTR_IS_FULL);
currentEntryCacheCount = getLong(ATTR_CURRENT_ENTRY_CACHE_COUNT);
entriesAddedOrUpdated = getLong(ATTR_ENTRIES_ADDED_OR_UPDATED);
entriesNotAddedAlreadyPresent =
getLong(ATTR_ENTRIES_NOT_ADDED_ALREADY_PRESENT);
entriesNotAddedDueToEntrySmallness =
getLong(ATTR_ENTRIES_NOT_ADDED_DUE_TO_ENTRY_SMALLNESS);
entriesNotAddedDueToFilter = getLong(ATTR_ENTRIES_NOT_ADDED_DUE_TO_FILTER);
entriesNotAddedDueToMaxMemory =
getLong(ATTR_ENTRIES_NOT_ADDED_DUE_TO_MAX_MEMORY);
entryCacheHitRatio = getLong(ATTR_ENTRY_CACHE_HIT_RATIO);
entryCacheHits = getLong(ATTR_ENTRY_CACHE_HITS);
entryCacheTries = getLong(ATTR_ENTRY_CACHE_TRIES);
evictionsDueToMaxEntries = getLong(ATTR_EVICTIONS_DUE_TO_MAX_ENTRIES);
evictionsDueToMaxMemory = getLong(ATTR_EVICTIONS_DUE_TO_MAX_MEMORY);
jvmMemoryBelowMaxMemoryPercent =
getLong(ATTR_JVM_MEMORY_BELOW_MAX_MEMORY_PERCENT);
jvmMemoryCurrentPercentFull = getLong(ATTR_JVM_MEMORY_CURRENT_PERCENT_FULL);
jvmMemoryMaxPercentThreshold =
getLong(ATTR_JVM_MEMORY_MAX_PERCENT_THRESHOLD);
lowMemoryOccurrences = getLong(ATTR_LOW_MEMORY_OCCURRENCES);
maxEntryCacheCount = getLong(ATTR_MAX_ENTRY_CACHE_COUNT);
maxEntryCacheSize = getLong(ATTR_MAX_ENTRY_CACHE_SIZE);
percentFullMaxEntries = getLong(ATTR_PERCENT_FULL_MAX_ENTRIES);
cacheName = getString(ATTR_CACHE_NAME);
capacityDetails = getString(ATTR_CAPACITY_DETAILS);
}
/**
* Retrieves the name of the associated FIFO entry cache.
*
* @return The name of the associated FIFO entry cache, or {@code null} if
* this was not included in the monitor entry.
*/
public String getCacheName()
{
return cacheName;
}
/**
* Retrieves the number of times that a requested entry was successfully found
* in the cache.
*
* @return The number of times that a requested entry was successfully found
* in the cache, or {@code null} if this was not included in the
* monitor entry.
*/
public Long getEntryCacheHits()
{
return entryCacheHits;
}
/**
* Retrieves the number of times that an attempt was made to retrieve an entry
* from the cache.
*
* @return The number of times that an attempt was made to retrieve an entry
* from the cache, or {@code null} if this was not included in the
* monitor entry.
*/
public Long getEntryCacheTries()
{
return entryCacheTries;
}
/**
* Retrieves the percentage of the time that a requested entry was
* successfully retrieved from the cache.
*
* @return The percentage of the time that a requested entry was successfully
* retrieved from the cache, or {@code null} if this was not included
* in the monitor entry.
*/
public Long getEntryCacheHitRatio()
{
return entryCacheHitRatio;
}
/**
* Retrieves the maximum amount of memory (in bytes) that the entry cache may
* consume.
*
* @return The maximum amount of memory (in bytes) that the entry cache may
* consume, or {@code null} if this was not included in the monitor
* entry.
*/
public Long getMaxEntryCacheSizeBytes()
{
return maxEntryCacheSize;
}
/**
* Retrieves the number of entries currently held in the entry cache.
*
* @return The number of entries currently held in the entry cache, or
* {@code null} if this was not included in the monitor entry.
*/
public Long getCurrentEntryCacheCount()
{
return currentEntryCacheCount;
}
/**
* Retrieves the maximum number of entries that may be held in the entry
* cache.
*
* @return The maximum number of entries that may be held in the entry cache,
* or {@code null} if this was not included in the monitor entry.
*/
public Long getMaxEntryCacheCount()
{
return maxEntryCacheCount;
}
/**
* Retrieves the total number of entries that have been added to or updated
* in the cache since it was enabled.
*
* @return The total number of entries that have been added to or updated in
* the cache since it was enabled, or {@code null} if this was not
* included in the monitor entry.
*/
public Long getEntriesAddedOrUpdated()
{
return entriesAddedOrUpdated;
}
/**
* Retrieves the number of times that an entry has been evicted from the cache
* because the maximum memory consumption had been reached.
*
* @return The number of times that an entry has been evicted from the cache
* because the maximum memory consumption had been reached, or
* {@code null} if this was not included in the monitor entry.
*/
public Long getEvictionsDueToMaxMemory()
{
return evictionsDueToMaxMemory;
}
/**
* Retrieves the maximum number of times that an entry has been evicted from
* the cache because it already contained the maximum number of entries.
*
* @return The maximum number of times that an entry has been evicted from
* the cache because it already contained the maximum number of
* entries, or {@code null} if this was not included in the monitor
* entry.
*/
public Long getEvictionsDueToMaxEntries()
{
return evictionsDueToMaxEntries;
}
/**
* Retrieves the number of times that an entry was not added to the cache
* because it was already present.
*
* @return The number of times that an entry was not added to the cache
* because it was already present, or {@code null} if this was not
* included in the monitor entry.
*/
public Long getEntriesNotAddedAlreadyPresent()
{
return entriesNotAddedAlreadyPresent;
}
/**
* Retrieves the number of times that an entry was not added to the cache
* because it was already at its maximum memory consumption.
*
* @return The number of times that an entry was not added to the cache
* because it was already at its maximum memory consumption, or
* {@code null} if this was not included in the monitor entry.
*/
public Long getEntriesNotAddedDueToMaxMemory()
{
return entriesNotAddedDueToMaxMemory;
}
/**
* Retrieves the number of times that an entry was not added to the cache
* because it did not match the filter criteria for including it.
*
* @return The number of times that an entry was not added to the cache
* because it did not match the filter criteria for including it, or
* {@code null} if this was not included in the monitor entry.
*/
public Long getEntriesNotAddedDueToFilter()
{
return entriesNotAddedDueToFilter;
}
/**
* Retrieves the number of times that an entry was not added to the cache
* because it did not have enough values to be considered for inclusion.
*
* @return The number of times that an entry was not added to the cache
* because it did not have enough values to be considered for
* inclusion, or {@code null} if this was not included in the monitor
* entry.
*/
public Long getEntriesNotAddedDueToEntrySmallness()
{
return entriesNotAddedDueToEntrySmallness;
}
/**
* Retrieves the number of times that entries had to be evicted from the
* cache because the available JVM memory became critically low.
*
* @return The number of times that entries had to be evicted from the cache
* because the available JVM memory had become critically low, or
* {@code null} if this was not included in the monitor entry.
*/
public Long getLowMemoryOccurrences()
{
return lowMemoryOccurrences;
}
/**
* Retrieves the percentage of the maximum allowed number of entries that are
* currently held in the cache.
*
* @return The percentage of the maximum allowed number of entries that are
* currently held in the cache, or {@code null} if this was not
* included in the monitor entry.
*/
public Long getPercentFullMaxEntries()
{
return percentFullMaxEntries;
}
/**
* Retrieves the maximum percent of JVM memory that may be consumed in order
* for new entries to be added to the cache.
*
* @return The maximum percent of JVM memory that may be consumed in order
* for new entries to be added to the cache, or {@code null} if this
* was not included in the monitor entry.
*/
public Long getJVMMemoryMaxPercentThreshold()
{
return jvmMemoryMaxPercentThreshold;
}
/**
* Retrieves the percentage of JVM memory that is currently being consumed.
*
* @return The percentage of JVM memory that is currently being consumed, or
* {@code null} if this was not included in the monitor entry.
*/
public Long getJVMMemoryCurrentPercentFull()
{
return jvmMemoryCurrentPercentFull;
}
/**
* Retrieves the difference between the JVM max memory percent threshold and
* the JVM memory current percent full. Note that this value may be negative
* if the JVM is currently consuming more memory than the maximum threshold.
*
* @return The difference between the JVM max memory percent threshold and
* the JVM memory current percent full, or {@code null} if this was
* not included in the monitor entry.
*/
public Long getJVMMemoryBelowMaxMemoryPercent()
{
return jvmMemoryBelowMaxMemoryPercent;
}
/**
* Indicates whether the entry cache is currently full, whether due to the
* maximum JVM memory consumption or the maximum number of entries allowed in
* the cache.
*
* @return {@code Boolean.TRUE} if the entry cache is currently full,
* {@code Boolean.FALSE} if the entry cache is not yet full, or
* {@code null} if this was not included in the monitor entry.
*/
public Boolean isFull()
{
return isFull;
}
/**
* Retrieves a human-readable message about the capacity and utilization of
* the entry cache.
*
* @return A human-readable message about the capacity and utilization of the
* entry cache, or {@code null} if this was not included in the
* monitor entry.
*/
public String getCapacityDetails()
{
return capacityDetails;
}
/**
* {@inheritDoc}
*/
@Override()
public String getMonitorDisplayName()
{
return INFO_FIFO_ENTRY_CACHE_MONITOR_DISPNAME.get();
}
/**
* {@inheritDoc}
*/
@Override()
public String getMonitorDescription()
{
return INFO_FIFO_ENTRY_CACHE_MONITOR_DESC.get();
}
/**
* {@inheritDoc}
*/
@Override()
public Map getMonitorAttributes()
{
final LinkedHashMap attrs =
new LinkedHashMap<>(StaticUtils.computeMapCapacity(30));
if (cacheName != null)
{
addMonitorAttribute(attrs,
ATTR_CACHE_NAME,
INFO_FIFO_ENTRY_CACHE_DISPNAME_CACHE_NAME.get(),
INFO_FIFO_ENTRY_CACHE_DESC_CACHE_NAME.get(),
cacheName);
}
if (entryCacheHits != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRY_CACHE_HITS,
INFO_FIFO_ENTRY_CACHE_DISPNAME_HITS.get(),
INFO_FIFO_ENTRY_CACHE_DESC_HITS.get(),
entryCacheHits);
}
if (entryCacheTries != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRY_CACHE_TRIES,
INFO_FIFO_ENTRY_CACHE_DISPNAME_TRIES.get(),
INFO_FIFO_ENTRY_CACHE_DESC_TRIES.get(),
entryCacheTries);
}
if (entryCacheHitRatio != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRY_CACHE_HIT_RATIO,
INFO_FIFO_ENTRY_CACHE_DISPNAME_HIT_RATIO.get(),
INFO_FIFO_ENTRY_CACHE_DESC_HIT_RATIO.get(),
entryCacheHitRatio);
}
if (maxEntryCacheSize != null)
{
addMonitorAttribute(attrs,
ATTR_MAX_ENTRY_CACHE_SIZE,
INFO_FIFO_ENTRY_CACHE_DISPNAME_MAX_MEM.get(),
INFO_FIFO_ENTRY_CACHE_DESC_MAX_MEM.get(),
maxEntryCacheSize);
}
if (currentEntryCacheCount != null)
{
addMonitorAttribute(attrs,
ATTR_CURRENT_ENTRY_CACHE_COUNT,
INFO_FIFO_ENTRY_CACHE_DISPNAME_CURRENT_COUNT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_CURRENT_COUNT.get(),
currentEntryCacheCount);
}
if (maxEntryCacheCount != null)
{
addMonitorAttribute(attrs,
ATTR_MAX_ENTRY_CACHE_COUNT,
INFO_FIFO_ENTRY_CACHE_DISPNAME_MAX_COUNT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_MAX_COUNT.get(),
maxEntryCacheCount);
}
if (entriesAddedOrUpdated != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRIES_ADDED_OR_UPDATED,
INFO_FIFO_ENTRY_CACHE_DISPNAME_PUT_COUNT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_PUT_COUNT.get(),
entriesAddedOrUpdated);
}
if (evictionsDueToMaxMemory != null)
{
addMonitorAttribute(attrs,
ATTR_EVICTIONS_DUE_TO_MAX_MEMORY,
INFO_FIFO_ENTRY_CACHE_DISPNAME_EVICT_MEM.get(),
INFO_FIFO_ENTRY_CACHE_DESC_EVICT_MEM.get(),
evictionsDueToMaxMemory);
}
if (evictionsDueToMaxEntries != null)
{
addMonitorAttribute(attrs,
ATTR_EVICTIONS_DUE_TO_MAX_ENTRIES,
INFO_FIFO_ENTRY_CACHE_DISPNAME_EVICT_COUNT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_EVICT_COUNT.get(),
evictionsDueToMaxEntries);
}
if (entriesNotAddedAlreadyPresent != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRIES_NOT_ADDED_ALREADY_PRESENT,
INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_ALREADY_PRESENT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_ALREADY_PRESENT.get(),
entriesNotAddedAlreadyPresent);
}
if (entriesNotAddedDueToMaxMemory != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRIES_NOT_ADDED_DUE_TO_MAX_MEMORY,
INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_MEM.get(),
INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_MEM.get(),
entriesNotAddedDueToMaxMemory);
}
if (entriesNotAddedDueToFilter != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRIES_NOT_ADDED_DUE_TO_FILTER,
INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_FILTER.get(),
INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_FILTER.get(),
entriesNotAddedDueToFilter);
}
if (entriesNotAddedDueToEntrySmallness != null)
{
addMonitorAttribute(attrs,
ATTR_ENTRIES_NOT_ADDED_DUE_TO_ENTRY_SMALLNESS,
INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_TOO_SMALL.get(),
INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_TOO_SMALL.get(),
entriesNotAddedDueToEntrySmallness);
}
if (lowMemoryOccurrences != null)
{
addMonitorAttribute(attrs,
ATTR_LOW_MEMORY_OCCURRENCES,
INFO_FIFO_ENTRY_CACHE_DISPNAME_LOW_MEM_COUNT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_LOW_MEM_COUNT.get(),
lowMemoryOccurrences);
}
if (percentFullMaxEntries != null)
{
addMonitorAttribute(attrs,
ATTR_PERCENT_FULL_MAX_ENTRIES,
INFO_FIFO_ENTRY_CACHE_DISPNAME_ENTRY_COUNT_PERCENT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_ENTRY_COUNT_PERCENT.get(),
percentFullMaxEntries);
}
if (jvmMemoryMaxPercentThreshold != null)
{
addMonitorAttribute(attrs,
ATTR_JVM_MEMORY_MAX_PERCENT_THRESHOLD,
INFO_FIFO_ENTRY_CACHE_DISPNAME_JVM_MEM_MAX_PERCENT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_JVM_MEM_MAX_PERCENT.get(),
jvmMemoryMaxPercentThreshold);
}
if (jvmMemoryCurrentPercentFull != null)
{
addMonitorAttribute(attrs,
ATTR_JVM_MEMORY_CURRENT_PERCENT_FULL,
INFO_FIFO_ENTRY_CACHE_DISPNAME_JVM_MEM_CURRENT_PERCENT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_JVM_MEM_CURRENT_PERCENT.get(),
jvmMemoryCurrentPercentFull);
}
if (jvmMemoryBelowMaxMemoryPercent != null)
{
addMonitorAttribute(attrs,
ATTR_JVM_MEMORY_BELOW_MAX_MEMORY_PERCENT,
INFO_FIFO_ENTRY_CACHE_DISPNAME_JVM_MEM_BELOW_MAX_PERCENT.get(),
INFO_FIFO_ENTRY_CACHE_DESC_JVM_MEM_BELOW_MAX_PERCENT.get(),
jvmMemoryBelowMaxMemoryPercent);
}
if (isFull != null)
{
addMonitorAttribute(attrs,
ATTR_IS_FULL,
INFO_FIFO_ENTRY_CACHE_DISPNAME_IS_FULL.get(),
INFO_FIFO_ENTRY_CACHE_DESC_IS_FULL.get(),
isFull);
}
if (capacityDetails != null)
{
addMonitorAttribute(attrs,
ATTR_CAPACITY_DETAILS,
INFO_FIFO_ENTRY_CACHE_DISPNAME_CAPACITY_DETAILS.get(),
INFO_FIFO_ENTRY_CACHE_DESC_CAPACITY_DETAILS.get(),
capacityDetails);
}
return Collections.unmodifiableMap(attrs);
}
}