001 /* 002 * Copyright 2011-2015 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005 /* 006 * Copyright (C) 2015 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021 package com.unboundid.ldap.sdk.unboundidds.monitors; 022 023 024 025 import java.util.Collections; 026 import java.util.LinkedHashMap; 027 import java.util.Map; 028 029 import com.unboundid.ldap.sdk.Entry; 030 import com.unboundid.util.NotMutable; 031 import com.unboundid.util.ThreadSafety; 032 import com.unboundid.util.ThreadSafetyLevel; 033 034 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 035 036 037 038 /** 039 * <BLOCKQUOTE> 040 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 041 * LDAP SDK for Java. It is not available for use in applications that 042 * include only the Standard Edition of the LDAP SDK, and is not supported for 043 * use in conjunction with non-UnboundID products. 044 * </BLOCKQUOTE> 045 * This class defines a monitor entry that provides information about the sate 046 * of a FIFO entry cache in the Directory Server. The information that may be 047 * available about the entry cache includes: 048 * <UL> 049 * <LI>The name assigned to the cache.</LI> 050 * <LI>The number of attempts (successful and total) and the hit ratio when 051 * trying to retrieve an entry from the cache.</LI> 052 * <LI>The maximum allowed size of the entry cache in entries and bytes.</LI> 053 * <LI>The number of entries currently held in the cache.</LI> 054 * <LI>The number of entries added to or updated in the cache.</LI> 055 * <LI>The number of times an entry was not added to the cache because it was 056 * already present.</LI> 057 * <LI>The number of times an entry was not added to the cache because it did 058 * not match filter criteria required for inclusion.</LI> 059 * <LI>The number of times an entry was not added to the cache because it was 060 * too small to be included.</LI> 061 * <LI>The number of times an entry was evicted because of memory pressure or 062 * to make room for new entries.</LI> 063 * <LI>Information about the current memory consumption of the cache and 064 * whether the cache is currently full.</LI> 065 * </UL> 066 * The server will automatically present one monitor entry for every FIFO entry 067 * cache defined in the server. It is possible to have multiple caches enabled 068 * if desired (e.g., one specifically targeting large static groups, and another 069 * small cache to help improve write-after-read performance). FIFO entry cache 070 * monitor entries can be retrieved using the 071 * {@link MonitorManager#getFIFOEntryCacheMonitorEntries} method. These monitor 072 * entries provide specific methods for accessing information about the FIFO 073 * entry cache. Alternately, this information may be accessed using the generic 074 * API. See the {@link MonitorManager} class documentation for an example that 075 * demonstrates the use of the generic API for accessing monitor data. 076 */ 077 @NotMutable() 078 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 079 public final class FIFOEntryCacheMonitorEntry 080 extends MonitorEntry 081 { 082 /** 083 * The structural object class used in entry cache monitor entries. 084 */ 085 static final String FIFO_ENTRY_CACHE_MONITOR_OC = 086 "ds-fifo-entry-cache-monitor-entry"; 087 088 089 090 /** 091 * The name of the attribute that holds the name of the associated FIFO entry 092 * cache. 093 */ 094 private static final String ATTR_CACHE_NAME = "cacheName"; 095 096 097 098 /** 099 * The name of the attribute that holds the number of cache hits. 100 */ 101 private static final String ATTR_ENTRY_CACHE_HITS = "entryCacheHits"; 102 103 104 105 /** 106 * The name of the attribute that holds the number of cache tries. 107 */ 108 private static final String ATTR_ENTRY_CACHE_TRIES = "entryCacheTries"; 109 110 111 112 /** 113 * The name of the attribute that holds the cache hit ratio. 114 */ 115 private static final String ATTR_ENTRY_CACHE_HIT_RATIO = "entryCacheHitRatio"; 116 117 118 119 /** 120 * The name of the attribute that holds the maximum cache size in bytes. 121 */ 122 private static final String ATTR_MAX_ENTRY_CACHE_SIZE = "maxEntryCacheSize"; 123 124 125 126 /** 127 * The name of the attribute that holds the number of entries currently in the 128 * cache. 129 */ 130 private static final String ATTR_CURRENT_ENTRY_CACHE_COUNT = 131 "currentEntryCacheCount"; 132 133 134 135 /** 136 * The name of the attribute that holds the maximum number of entries that may 137 * be held in the cache. 138 */ 139 private static final String ATTR_MAX_ENTRY_CACHE_COUNT = "maxEntryCacheCount"; 140 141 142 143 /** 144 * The name of the attribute that holds the number of entries added to or 145 * replaced in the cache. 146 */ 147 private static final String ATTR_ENTRIES_ADDED_OR_UPDATED = 148 "entriesAddedOrUpdated"; 149 150 151 152 /** 153 * The name of the attribute that holds the number of entries evicted because 154 * the entry cache had reached its maximum memory allocation. 155 */ 156 private static final String ATTR_EVICTIONS_DUE_TO_MAX_MEMORY = 157 "evictionsDueToMaxMemory"; 158 159 160 161 /** 162 * The name of the attribute that holds the number of entries evicted because 163 * the entry cache had reached its maximum entry count. 164 */ 165 private static final String ATTR_EVICTIONS_DUE_TO_MAX_ENTRIES = 166 "evictionsDueToMaxEntries"; 167 168 169 170 /** 171 * The name of the attribute that holds the number of entries that were not 172 * added because they were already present in the cache. 173 */ 174 private static final String ATTR_ENTRIES_NOT_ADDED_ALREADY_PRESENT = 175 "entriesNotAddedAlreadyPresent"; 176 177 178 179 /** 180 * The name of the attribute that holds the number of entries that were not 181 * added because the cache had reached its maximum memory allocation. 182 */ 183 private static final String ATTR_ENTRIES_NOT_ADDED_DUE_TO_MAX_MEMORY = 184 "entriesNotAddedDueToMaxMemory"; 185 186 187 188 /** 189 * The name of the attribute that holds the number of entries that were not 190 * added because they did not meet the necessary filter criteria. 191 */ 192 private static final String ATTR_ENTRIES_NOT_ADDED_DUE_TO_FILTER = 193 "entriesNotAddedDueToFilter"; 194 195 196 197 /** 198 * The name of the attribute that holds the number of entries that were not 199 * added because they did not have enough values to be considered for 200 * inclusion in the cache. 201 */ 202 private static final String ATTR_ENTRIES_NOT_ADDED_DUE_TO_ENTRY_SMALLNESS = 203 "entriesNotAddedDueToEntrySmallness"; 204 205 206 207 /** 208 * The name of the attribute that holds the number of times that entries were 209 * purged from the cache because the JVM was running low on memory. 210 */ 211 private static final String ATTR_LOW_MEMORY_OCCURRENCES = 212 "lowMemoryOccurrences"; 213 214 215 216 /** 217 * The name of the attribute that holds the percentage of the maximum allowed 218 * number of entries that are currently held in the cache. 219 */ 220 private static final String ATTR_PERCENT_FULL_MAX_ENTRIES = 221 "percentFullMaxEntries"; 222 223 224 225 /** 226 * The name of the attribute that holds the maximum percent of JVM memory that 227 * may be consumed before entries may stop being added to the cache. 228 */ 229 private static final String ATTR_JVM_MEMORY_MAX_PERCENT_THRESHOLD = 230 "jvmMemoryMaxPercentThreshold"; 231 232 233 234 /** 235 * The name of the attribute that holds the percent of JVM memory that is 236 * currently consumed. 237 */ 238 private static final String ATTR_JVM_MEMORY_CURRENT_PERCENT_FULL = 239 "jvmMemoryCurrentPercentFull"; 240 241 242 243 /** 244 * The name of the attribute that holds the difference between the maximum 245 * memory percent threshold and the current percent full. 246 */ 247 private static final String ATTR_JVM_MEMORY_BELOW_MAX_MEMORY_PERCENT = 248 "jvmMemoryBelowMaxMemoryPercent"; 249 250 251 252 /** 253 * The name of the attribute that indicates whether the entry cache is 254 * currently full (based on memory usage or number of entries). 255 */ 256 private static final String ATTR_IS_FULL = "isFull"; 257 258 259 260 /** 261 * The name of the attribute that holds a human-readable message about the 262 * capacity and utilization of the cache. 263 */ 264 private static final String ATTR_CAPACITY_DETAILS = "capacityDetails"; 265 266 267 268 /** 269 * The serial version UID for this serializable class. 270 */ 271 private static final long serialVersionUID = -3340643698412829407L; 272 273 274 275 // The value of the isFull attribute. 276 private final Boolean isFull; 277 278 // The value of the currentEntryCacheCount attribute. 279 private final Long currentEntryCacheCount; 280 281 // The value of the entriesAddedOrUpdated attribute. 282 private final Long entriesAddedOrUpdated; 283 284 // The value of the entriesNotAddedAlreadyPresent attribute. 285 private final Long entriesNotAddedAlreadyPresent; 286 287 // The value of the entriesNotAddedDueToEntrySmallness attribute. 288 private final Long entriesNotAddedDueToEntrySmallness; 289 290 // The value of the entriesNotAddedDueToFilter attribute. 291 private final Long entriesNotAddedDueToFilter; 292 293 // The value of the entriesNotAddedDueToMaxMemory attribute. 294 private final Long entriesNotAddedDueToMaxMemory; 295 296 // The value of the entryCacheHitRatio attribute. 297 private final Long entryCacheHitRatio; 298 299 // The value of the entryCacheHits attribute. 300 private final Long entryCacheHits; 301 302 // The value of the entryCacheTries attribute. 303 private final Long entryCacheTries; 304 305 // The value of the evictionsDueToMaxEntries attribute. 306 private final Long evictionsDueToMaxEntries; 307 308 // The value of the evictionsDueToMaxMemory attribute. 309 private final Long evictionsDueToMaxMemory; 310 311 // The value of the jvmMemoryBelowMaxMemoryPercent attribute. 312 private final Long jvmMemoryBelowMaxMemoryPercent; 313 314 // The value of the jvmMemoryCurrentPercentFull attribute. 315 private final Long jvmMemoryCurrentPercentFull; 316 317 // The value of the jvmMemoryMaxPercentThreshold attribute. 318 private final Long jvmMemoryMaxPercentThreshold; 319 320 // The value of the lowMemoryOccurrences attribute. 321 private final Long lowMemoryOccurrences; 322 323 // The value of the maxEntryCacheCount attribute. 324 private final Long maxEntryCacheCount; 325 326 // The value of the maxEntryCacheSize attribute. 327 private final Long maxEntryCacheSize; 328 329 // The value of the percentFullMaxEntries attribute. 330 private final Long percentFullMaxEntries; 331 332 // The value of the cacheName attribute. 333 private final String cacheName; 334 335 // The value of the capacityDetails attribute. 336 private final String capacityDetails; 337 338 339 340 /** 341 * Creates a new FIFO entry cache monitor entry from the provided entry. 342 * 343 * @param entry The entry to be parsed as a FIFO entry cache monitor entry. 344 * It must not be {@code null}. 345 */ 346 public FIFOEntryCacheMonitorEntry(final Entry entry) 347 { 348 super(entry); 349 350 isFull = getBoolean(ATTR_IS_FULL); 351 currentEntryCacheCount = getLong(ATTR_CURRENT_ENTRY_CACHE_COUNT); 352 entriesAddedOrUpdated = getLong(ATTR_ENTRIES_ADDED_OR_UPDATED); 353 entriesNotAddedAlreadyPresent = 354 getLong(ATTR_ENTRIES_NOT_ADDED_ALREADY_PRESENT); 355 entriesNotAddedDueToEntrySmallness = 356 getLong(ATTR_ENTRIES_NOT_ADDED_DUE_TO_ENTRY_SMALLNESS); 357 entriesNotAddedDueToFilter = getLong(ATTR_ENTRIES_NOT_ADDED_DUE_TO_FILTER); 358 entriesNotAddedDueToMaxMemory = 359 getLong(ATTR_ENTRIES_NOT_ADDED_DUE_TO_MAX_MEMORY); 360 entryCacheHitRatio = getLong(ATTR_ENTRY_CACHE_HIT_RATIO); 361 entryCacheHits = getLong(ATTR_ENTRY_CACHE_HITS); 362 entryCacheTries = getLong(ATTR_ENTRY_CACHE_TRIES); 363 evictionsDueToMaxEntries = getLong(ATTR_EVICTIONS_DUE_TO_MAX_ENTRIES); 364 evictionsDueToMaxMemory = getLong(ATTR_EVICTIONS_DUE_TO_MAX_MEMORY); 365 jvmMemoryBelowMaxMemoryPercent = 366 getLong(ATTR_JVM_MEMORY_BELOW_MAX_MEMORY_PERCENT); 367 jvmMemoryCurrentPercentFull = getLong(ATTR_JVM_MEMORY_CURRENT_PERCENT_FULL); 368 jvmMemoryMaxPercentThreshold = 369 getLong(ATTR_JVM_MEMORY_MAX_PERCENT_THRESHOLD); 370 lowMemoryOccurrences = getLong(ATTR_LOW_MEMORY_OCCURRENCES); 371 maxEntryCacheCount = getLong(ATTR_MAX_ENTRY_CACHE_COUNT); 372 maxEntryCacheSize = getLong(ATTR_MAX_ENTRY_CACHE_SIZE); 373 percentFullMaxEntries = getLong(ATTR_PERCENT_FULL_MAX_ENTRIES); 374 cacheName = getString(ATTR_CACHE_NAME); 375 capacityDetails = getString(ATTR_CAPACITY_DETAILS); 376 } 377 378 379 380 /** 381 * Retrieves the name of the associated FIFO entry cache. 382 * 383 * @return The name of the associated FIFO entry cache, or {@code null} if 384 * this was not included in the monitor entry. 385 */ 386 public String getCacheName() 387 { 388 return cacheName; 389 } 390 391 392 393 /** 394 * Retrieves the number of times that a requested entry was successfully found 395 * in the cache. 396 * 397 * @return The number of times that a requested entry was successfully found 398 * in the cache, or {@code null} if this was not included in the 399 * monitor entry. 400 */ 401 public Long getEntryCacheHits() 402 { 403 return entryCacheHits; 404 } 405 406 407 408 /** 409 * Retrieves the number of times that an attempt was made to retrieve an entry 410 * from the cache. 411 * 412 * @return The number of times that an attempt was made to retrieve an entry 413 * from the cache, or {@code null} if this was not included in the 414 * monitor entry. 415 */ 416 public Long getEntryCacheTries() 417 { 418 return entryCacheTries; 419 } 420 421 422 423 /** 424 * Retrieves the percentage of the time that a requested entry was 425 * successfully retrieved from the cache. 426 * 427 * @return The percentage of the time that a requested entry was successfully 428 * retrieved from the cache, or {@code null} if this was not included 429 * in the monitor entry. 430 */ 431 public Long getEntryCacheHitRatio() 432 { 433 return entryCacheHitRatio; 434 } 435 436 437 438 /** 439 * Retrieves the maximum amount of memory (in bytes) that the entry cache may 440 * consume. 441 * 442 * @return The maximum amount of memory (in bytes) that the entry cache may 443 * consume, or {@code null} if this was not included in the monitor 444 * entry. 445 */ 446 public Long getMaxEntryCacheSizeBytes() 447 { 448 return maxEntryCacheSize; 449 } 450 451 452 453 /** 454 * Retrieves the number of entries currently held in the entry cache. 455 * 456 * @return The number of entries currently held in the entry cache, or 457 * {@code null} if this was not included in the monitor entry. 458 */ 459 public Long getCurrentEntryCacheCount() 460 { 461 return currentEntryCacheCount; 462 } 463 464 465 466 /** 467 * Retrieves the maximum number of entries that may be held in the entry 468 * cache. 469 * 470 * @return The maximum number of entries that may be held in the entry cache, 471 * or {@code null} if this was not included in the monitor entry. 472 */ 473 public Long getMaxEntryCacheCount() 474 { 475 return maxEntryCacheCount; 476 } 477 478 479 480 /** 481 * Retrieves the total number of entries that have been added to or updated 482 * in the cache since it was enabled. 483 * 484 * @return The total number of entries that have been added to or updated in 485 * the cache since it was enabled, or {@code null} if this was not 486 * included in the monitor entry. 487 */ 488 public Long getEntriesAddedOrUpdated() 489 { 490 return entriesAddedOrUpdated; 491 } 492 493 494 495 /** 496 * Retrieves the number of times that an entry has been evicted from the cache 497 * because the maximum memory consumption had been reached. 498 * 499 * @return The number of times that an entry has been evicted from the cache 500 * because the maximum memory consumption had been reached, or 501 * {@code null} if this was not included in the monitor entry. 502 */ 503 public Long getEvictionsDueToMaxMemory() 504 { 505 return evictionsDueToMaxMemory; 506 } 507 508 509 510 /** 511 * Retrieves the maximum number of times that an entry has been evicted from 512 * the cache because it already contained the maximum number of entries. 513 * 514 * @return The maximum number of times that an entry has been evicted from 515 * the cache because it already contained the maximum number of 516 * entries, or {@code null} if this was not included in the monitor 517 * entry. 518 */ 519 public Long getEvictionsDueToMaxEntries() 520 { 521 return evictionsDueToMaxEntries; 522 } 523 524 525 526 /** 527 * Retrieves the number of times that an entry was not added to the cache 528 * because it was already present. 529 * 530 * @return The number of times that an entry was not added to the cache 531 * because it was already present, or {@code null} if this was not 532 * included in the monitor entry. 533 */ 534 public Long getEntriesNotAddedAlreadyPresent() 535 { 536 return entriesNotAddedAlreadyPresent; 537 } 538 539 540 541 /** 542 * Retrieves the number of times that an entry was not added to the cache 543 * because it was already at its maximum memory consumption. 544 * 545 * @return The number of times that an entry was not added to the cache 546 * because it was already at its maximum memory consumption, or 547 * {@code null} if this was not included in the monitor entry. 548 */ 549 public Long getEntriesNotAddedDueToMaxMemory() 550 { 551 return entriesNotAddedDueToMaxMemory; 552 } 553 554 555 556 /** 557 * Retrieves the number of times that an entry was not added to the cache 558 * because it did not match the filter criteria for including it. 559 * 560 * @return The number of times that an entry was not added to the cache 561 * because it did not match the filter criteria for including it, or 562 * {@code null} if this was not included in the monitor entry. 563 */ 564 public Long getEntriesNotAddedDueToFilter() 565 { 566 return entriesNotAddedDueToFilter; 567 } 568 569 570 571 /** 572 * Retrieves the number of times that an entry was not added to the cache 573 * because it did not have enough values to be considered for inclusion. 574 * 575 * @return The number of times that an entry was not added to the cache 576 * because it did not have enough values to be considered for 577 * inclusion, or {@code null} if this was not included in the monitor 578 * entry. 579 */ 580 public Long getEntriesNotAddedDueToEntrySmallness() 581 { 582 return entriesNotAddedDueToEntrySmallness; 583 } 584 585 586 587 /** 588 * Retrieves the number of times that entries had to be evicted from the 589 * cache because the available JVM memory became critically low. 590 * 591 * @return The number of times that entries had to be evicted from the cache 592 * because the available JVM memory had become critically low, or 593 * {@code null} if this was not included in the monitor entry. 594 */ 595 public Long getLowMemoryOccurrences() 596 { 597 return lowMemoryOccurrences; 598 } 599 600 601 602 /** 603 * Retrieves the percentage of the maximum allowed number of entries that are 604 * currently held in the cache. 605 * 606 * @return The percentage of the maximum allowed number of entries that are 607 * currently held in the cache, or {@code null} if this was not 608 * included in the monitor entry. 609 */ 610 public Long getPercentFullMaxEntries() 611 { 612 return percentFullMaxEntries; 613 } 614 615 616 617 /** 618 * Retrieves the maximum percent of JVM memory that may be consumed in order 619 * for new entries to be added to the cache. 620 * 621 * @return The maximum percent of JVM memory that may be consumed in order 622 * for new entries to be added to the cache, or {@code null} if this 623 * was not included in the monitor entry. 624 */ 625 public Long getJVMMemoryMaxPercentThreshold() 626 { 627 return jvmMemoryMaxPercentThreshold; 628 } 629 630 631 632 /** 633 * Retrieves the percentage of JVM memory that is currently being consumed. 634 * 635 * @return The percentage of JVM memory that is currently being consumed, or 636 * {@code null} if this was not included in the monitor entry. 637 */ 638 public Long getJVMMemoryCurrentPercentFull() 639 { 640 return jvmMemoryCurrentPercentFull; 641 } 642 643 644 645 /** 646 * Retrieves the difference between the JVM max memory percent threshold and 647 * the JVM memory current percent full. Note that this value may be negative 648 * if the JVM is currently consuming more memory than the maximum threshold. 649 * 650 * @return The difference between the JVM max memory percent threshold and 651 * the JVM memory current percent full, or {@code null} if this was 652 * not included in the monitor entry. 653 */ 654 public Long getJVMMemoryBelowMaxMemoryPercent() 655 { 656 return jvmMemoryBelowMaxMemoryPercent; 657 } 658 659 660 661 /** 662 * Indicates whether the entry cache is currently full, whether due to the 663 * maximum JVM memory consumption or the maximum number of entries allowed in 664 * the cache. 665 * 666 * @return {@code Boolean.TRUE} if the entry cache is currently full, 667 * {@code Boolean.FALSE} if the entry cache is not yet full, or 668 * {@code null} if this was not included in the monitor entry. 669 */ 670 public Boolean isFull() 671 { 672 return isFull; 673 } 674 675 676 677 /** 678 * Retrieves a human-readable message about the capacity and utilization of 679 * the entry cache. 680 * 681 * @return A human-readable message about the capacity and utilization of the 682 * entry cache, or {@code null} if this was not included in the 683 * monitor entry. 684 */ 685 public String getCapacityDetails() 686 { 687 return capacityDetails; 688 } 689 690 691 692 /** 693 * {@inheritDoc} 694 */ 695 @Override() 696 public String getMonitorDisplayName() 697 { 698 return INFO_FIFO_ENTRY_CACHE_MONITOR_DISPNAME.get(); 699 } 700 701 702 703 /** 704 * {@inheritDoc} 705 */ 706 @Override() 707 public String getMonitorDescription() 708 { 709 return INFO_FIFO_ENTRY_CACHE_MONITOR_DESC.get(); 710 } 711 712 713 714 /** 715 * {@inheritDoc} 716 */ 717 @Override() 718 public Map<String,MonitorAttribute> getMonitorAttributes() 719 { 720 final LinkedHashMap<String,MonitorAttribute> attrs = 721 new LinkedHashMap<String,MonitorAttribute>(30); 722 723 if (cacheName != null) 724 { 725 addMonitorAttribute(attrs, 726 ATTR_CACHE_NAME, 727 INFO_FIFO_ENTRY_CACHE_DISPNAME_CACHE_NAME.get(), 728 INFO_FIFO_ENTRY_CACHE_DESC_CACHE_NAME.get(), 729 cacheName); 730 } 731 732 if (entryCacheHits != null) 733 { 734 addMonitorAttribute(attrs, 735 ATTR_ENTRY_CACHE_HITS, 736 INFO_FIFO_ENTRY_CACHE_DISPNAME_HITS.get(), 737 INFO_FIFO_ENTRY_CACHE_DESC_HITS.get(), 738 entryCacheHits); 739 } 740 741 if (entryCacheTries != null) 742 { 743 addMonitorAttribute(attrs, 744 ATTR_ENTRY_CACHE_TRIES, 745 INFO_FIFO_ENTRY_CACHE_DISPNAME_TRIES.get(), 746 INFO_FIFO_ENTRY_CACHE_DESC_TRIES.get(), 747 entryCacheTries); 748 } 749 750 if (entryCacheHitRatio != null) 751 { 752 addMonitorAttribute(attrs, 753 ATTR_ENTRY_CACHE_HIT_RATIO, 754 INFO_FIFO_ENTRY_CACHE_DISPNAME_HIT_RATIO.get(), 755 INFO_FIFO_ENTRY_CACHE_DESC_HIT_RATIO.get(), 756 entryCacheHitRatio); 757 } 758 759 if (maxEntryCacheSize != null) 760 { 761 addMonitorAttribute(attrs, 762 ATTR_MAX_ENTRY_CACHE_SIZE, 763 INFO_FIFO_ENTRY_CACHE_DISPNAME_MAX_MEM.get(), 764 INFO_FIFO_ENTRY_CACHE_DESC_MAX_MEM.get(), 765 maxEntryCacheSize); 766 } 767 768 if (currentEntryCacheCount != null) 769 { 770 addMonitorAttribute(attrs, 771 ATTR_CURRENT_ENTRY_CACHE_COUNT, 772 INFO_FIFO_ENTRY_CACHE_DISPNAME_CURRENT_COUNT.get(), 773 INFO_FIFO_ENTRY_CACHE_DESC_CURRENT_COUNT.get(), 774 currentEntryCacheCount); 775 } 776 777 if (maxEntryCacheCount != null) 778 { 779 addMonitorAttribute(attrs, 780 ATTR_MAX_ENTRY_CACHE_COUNT, 781 INFO_FIFO_ENTRY_CACHE_DISPNAME_MAX_COUNT.get(), 782 INFO_FIFO_ENTRY_CACHE_DESC_MAX_COUNT.get(), 783 maxEntryCacheCount); 784 } 785 786 if (entriesAddedOrUpdated != null) 787 { 788 addMonitorAttribute(attrs, 789 ATTR_ENTRIES_ADDED_OR_UPDATED, 790 INFO_FIFO_ENTRY_CACHE_DISPNAME_PUT_COUNT.get(), 791 INFO_FIFO_ENTRY_CACHE_DESC_PUT_COUNT.get(), 792 entriesAddedOrUpdated); 793 } 794 795 if (evictionsDueToMaxMemory != null) 796 { 797 addMonitorAttribute(attrs, 798 ATTR_EVICTIONS_DUE_TO_MAX_MEMORY, 799 INFO_FIFO_ENTRY_CACHE_DISPNAME_EVICT_MEM.get(), 800 INFO_FIFO_ENTRY_CACHE_DESC_EVICT_MEM.get(), 801 evictionsDueToMaxMemory); 802 } 803 804 if (evictionsDueToMaxEntries != null) 805 { 806 addMonitorAttribute(attrs, 807 ATTR_EVICTIONS_DUE_TO_MAX_ENTRIES, 808 INFO_FIFO_ENTRY_CACHE_DISPNAME_EVICT_COUNT.get(), 809 INFO_FIFO_ENTRY_CACHE_DESC_EVICT_COUNT.get(), 810 evictionsDueToMaxEntries); 811 } 812 813 if (entriesNotAddedAlreadyPresent != null) 814 { 815 addMonitorAttribute(attrs, 816 ATTR_ENTRIES_NOT_ADDED_ALREADY_PRESENT, 817 INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_ALREADY_PRESENT.get(), 818 INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_ALREADY_PRESENT.get(), 819 entriesNotAddedAlreadyPresent); 820 } 821 822 if (entriesNotAddedDueToMaxMemory != null) 823 { 824 addMonitorAttribute(attrs, 825 ATTR_ENTRIES_NOT_ADDED_DUE_TO_MAX_MEMORY, 826 INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_MEM.get(), 827 INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_MEM.get(), 828 entriesNotAddedDueToMaxMemory); 829 } 830 831 if (entriesNotAddedDueToFilter != null) 832 { 833 addMonitorAttribute(attrs, 834 ATTR_ENTRIES_NOT_ADDED_DUE_TO_FILTER, 835 INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_FILTER.get(), 836 INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_FILTER.get(), 837 entriesNotAddedDueToFilter); 838 } 839 840 if (entriesNotAddedDueToEntrySmallness != null) 841 { 842 addMonitorAttribute(attrs, 843 ATTR_ENTRIES_NOT_ADDED_DUE_TO_ENTRY_SMALLNESS, 844 INFO_FIFO_ENTRY_CACHE_DISPNAME_NO_PUT_TOO_SMALL.get(), 845 INFO_FIFO_ENTRY_CACHE_DESC_NO_PUT_TOO_SMALL.get(), 846 entriesNotAddedDueToEntrySmallness); 847 } 848 849 if (lowMemoryOccurrences != null) 850 { 851 addMonitorAttribute(attrs, 852 ATTR_LOW_MEMORY_OCCURRENCES, 853 INFO_FIFO_ENTRY_CACHE_DISPNAME_LOW_MEM_COUNT.get(), 854 INFO_FIFO_ENTRY_CACHE_DESC_LOW_MEM_COUNT.get(), 855 lowMemoryOccurrences); 856 } 857 858 if (percentFullMaxEntries != null) 859 { 860 addMonitorAttribute(attrs, 861 ATTR_PERCENT_FULL_MAX_ENTRIES, 862 INFO_FIFO_ENTRY_CACHE_DISPNAME_ENTRY_COUNT_PERCENT.get(), 863 INFO_FIFO_ENTRY_CACHE_DESC_ENTRY_COUNT_PERCENT.get(), 864 percentFullMaxEntries); 865 } 866 867 if (jvmMemoryMaxPercentThreshold != null) 868 { 869 addMonitorAttribute(attrs, 870 ATTR_JVM_MEMORY_MAX_PERCENT_THRESHOLD, 871 INFO_FIFO_ENTRY_CACHE_DISPNAME_JVM_MEM_MAX_PERCENT.get(), 872 INFO_FIFO_ENTRY_CACHE_DESC_JVM_MEM_MAX_PERCENT.get(), 873 jvmMemoryMaxPercentThreshold); 874 } 875 876 if (jvmMemoryCurrentPercentFull != null) 877 { 878 addMonitorAttribute(attrs, 879 ATTR_JVM_MEMORY_CURRENT_PERCENT_FULL, 880 INFO_FIFO_ENTRY_CACHE_DISPNAME_JVM_MEM_CURRENT_PERCENT.get(), 881 INFO_FIFO_ENTRY_CACHE_DESC_JVM_MEM_CURRENT_PERCENT.get(), 882 jvmMemoryCurrentPercentFull); 883 } 884 885 if (jvmMemoryBelowMaxMemoryPercent != null) 886 { 887 addMonitorAttribute(attrs, 888 ATTR_JVM_MEMORY_BELOW_MAX_MEMORY_PERCENT, 889 INFO_FIFO_ENTRY_CACHE_DISPNAME_JVM_MEM_BELOW_MAX_PERCENT.get(), 890 INFO_FIFO_ENTRY_CACHE_DESC_JVM_MEM_BELOW_MAX_PERCENT.get(), 891 jvmMemoryBelowMaxMemoryPercent); 892 } 893 894 if (isFull != null) 895 { 896 addMonitorAttribute(attrs, 897 ATTR_IS_FULL, 898 INFO_FIFO_ENTRY_CACHE_DISPNAME_IS_FULL.get(), 899 INFO_FIFO_ENTRY_CACHE_DESC_IS_FULL.get(), 900 isFull); 901 } 902 903 if (capacityDetails != null) 904 { 905 addMonitorAttribute(attrs, 906 ATTR_CAPACITY_DETAILS, 907 INFO_FIFO_ENTRY_CACHE_DISPNAME_CAPACITY_DETAILS.get(), 908 INFO_FIFO_ENTRY_CACHE_DESC_CAPACITY_DETAILS.get(), 909 capacityDetails); 910 } 911 912 return Collections.unmodifiableMap(attrs); 913 } 914 }