org.ehcache.impl.internal.statistics.DefaultTierStatistics Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of ehcache-impl Show documentation
The implementation module of Ehcache 3
There is a newer version: 3.10.8
/*
 * Copyright Terracotta, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.ehcache.impl.internal.statistics;

import org.ehcache.Cache;
import org.ehcache.core.statistics.StoreOperationOutcomes;
import org.ehcache.core.statistics.TierOperationOutcomes;
import org.ehcache.core.statistics.TierStatistics;
import org.terracotta.statistics.OperationStatistic;
import org.terracotta.statistics.ValueStatistic;
import org.terracotta.statistics.ZeroOperationStatistic;

import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static org.ehcache.impl.internal.statistics.StatsUtils.findStatisticOnDescendants;
import static org.terracotta.statistics.ValueStatistics.counter;
import static org.terracotta.statistics.ValueStatistics.gauge;

/**
 * Contains usage statistics relative to a given tier.
 */
class DefaultTierStatistics implements TierStatistics {

  private volatile CompensatingCounters compensatingCounters = CompensatingCounters.empty();

  private final Map> knownStatistics;

  private final OperationStatistic get;
  private final OperationStatistic put;
  private final OperationStatistic putIfAbsent;
  private final OperationStatistic replace;
  private final OperationStatistic conditionalReplace;
  private final OperationStatistic remove;
  private final OperationStatistic conditionalRemove;
  private final OperationStatistic eviction;
  private final OperationStatistic expiration;
  private final OperationStatistic compute;
  private final OperationStatistic computeIfAbsent;

  //Ehcache default to -1 if unavailable, but the management layer needs optional or null
  // (since -1 can be a normal value for a stat).
  private final Optional> mapping;
  private final Optional> allocatedMemory;
  private final Optional> occupiedMemory;

  public DefaultTierStatistics(Cache cache, String tierName) {

    get = findOperationStatistic(cache, tierName, "tier", "get");
    put = findOperationStatistic(cache, tierName, "put");
    putIfAbsent = findOperationStatistic(cache, tierName, "putIfAbsent");
    replace = findOperationStatistic(cache, tierName, "replace");
    conditionalReplace = findOperationStatistic(cache, tierName, "conditionalReplace");
    remove = findOperationStatistic(cache, tierName, "remove");
    conditionalRemove = findOperationStatistic(cache, tierName, "conditionalRemove");
    eviction = findOperationStatistic(cache, tierName, "tier", "eviction");
    expiration = findOperationStatistic(cache, tierName, "expiration");
    compute = findOperationStatistic(cache, tierName, "compute");
    computeIfAbsent = findOperationStatistic(cache, tierName, "computeIfAbsent");

    mapping = findValueStatistics(cache, tierName, "mappings");
    allocatedMemory = findValueStatistics(cache, tierName, "allocatedMemory");
    occupiedMemory = findValueStatistics(cache, tierName, "occupiedMemory");

    Map> knownStatistics = createKnownStatistics(tierName);
    this.knownStatistics = Collections.unmodifiableMap(knownStatistics);
  }

  private Map> createKnownStatistics(String tierName) {
    Map> knownStatistics = new HashMap<>(7);
    knownStatistics.put(tierName + ":HitCount", counter(this::getHits));
    knownStatistics.put(tierName + ":MissCount", counter(this::getMisses));
    knownStatistics.put(tierName + ":PutCount", counter(this::getPuts));
    knownStatistics.put(tierName + ":RemovalCount", counter(this::getRemovals));
    knownStatistics.put(tierName + ":EvictionCount", counter(this::getEvictions));
    knownStatistics.put(tierName + ":ExpirationCount", counter(this::getExpirations));
    mapping.ifPresent(longValueStatistic -> knownStatistics.put(tierName + ":MappingCount", counter(this::getMappings)));
    allocatedMemory.ifPresent(longValueStatistic -> knownStatistics.put(tierName + ":AllocatedByteSize", gauge(this::getAllocatedByteSize)));
    occupiedMemory.ifPresent(longValueStatistic -> knownStatistics.put(tierName + ":OccupiedByteSize", gauge(this::getOccupiedByteSize)));
    return knownStatistics;
  }

  @Override
  public Map> getKnownStatistics() {
    return knownStatistics;
  }

  private > OperationStatistic findOperationStatistic(Cache cache, String tierName, String tag, String stat) {
    return StatsUtils.>findStatisticOnDescendants(cache, tierName, tag, stat).orElse(ZeroOperationStatistic.get());
  }

  private > OperationStatistic findOperationStatistic(Cache cache, String tierName, String stat) {
    return StatsUtils.>findStatisticOnDescendants(cache, tierName, stat).orElse(ZeroOperationStatistic.get());
  }

  private Optional> findValueStatistics(Cache cache, String tierName, String statName) {
    return findStatisticOnDescendants(cache, tierName, statName);
  }

  /**
   * Reset the values for this tier. However, note that {@code mapping, allocatedMemory, occupiedMemory}
   * but be reset since it doesn't make sense.
   */
  @Override
  public void clear() {
    compensatingCounters = compensatingCounters.snapshot(this);
  }

  @Override
  public long getHits() {
    return get.sum(EnumSet.of(TierOperationOutcomes.GetOutcome.HIT)) +
           putIfAbsent.sum(EnumSet.of(StoreOperationOutcomes.PutIfAbsentOutcome.HIT)) +
           replace.sum(EnumSet.of(StoreOperationOutcomes.ReplaceOutcome.REPLACED)) +
           compute.sum(EnumSet.of(StoreOperationOutcomes.ComputeOutcome.HIT)) +
           computeIfAbsent.sum(EnumSet.of(StoreOperationOutcomes.ComputeIfAbsentOutcome.HIT)) +
           conditionalReplace.sum(EnumSet.of(StoreOperationOutcomes.ConditionalReplaceOutcome.REPLACED)) +
           conditionalRemove.sum(EnumSet.of(StoreOperationOutcomes.ConditionalRemoveOutcome.REMOVED)) -
           compensatingCounters.hits;
  }

  @Override
  public long getMisses() {
    return get.sum(EnumSet.of(TierOperationOutcomes.GetOutcome.MISS)) +
           putIfAbsent.sum(EnumSet.of(StoreOperationOutcomes.PutIfAbsentOutcome.PUT)) +
           replace.sum(EnumSet.of(StoreOperationOutcomes.ReplaceOutcome.MISS)) +
           computeIfAbsent.sum(EnumSet.of(StoreOperationOutcomes.ComputeIfAbsentOutcome.NOOP)) +
           conditionalReplace.sum(EnumSet.of(StoreOperationOutcomes.ConditionalReplaceOutcome.MISS)) +
           conditionalRemove.sum(EnumSet.of(StoreOperationOutcomes.ConditionalRemoveOutcome.MISS)) -
           compensatingCounters.misses;
  }

  @Override
  public long getPuts() {
    return put.sum(EnumSet.of(StoreOperationOutcomes.PutOutcome.PUT)) +
           putIfAbsent.sum(EnumSet.of(StoreOperationOutcomes.PutIfAbsentOutcome.PUT)) +
           compute.sum(EnumSet.of(StoreOperationOutcomes.ComputeOutcome.PUT)) +
           computeIfAbsent.sum(EnumSet.of(StoreOperationOutcomes.ComputeIfAbsentOutcome.PUT)) +
           replace.sum(EnumSet.of(StoreOperationOutcomes.ReplaceOutcome.REPLACED)) +
           conditionalReplace.sum(EnumSet.of(StoreOperationOutcomes.ConditionalReplaceOutcome.REPLACED)) -
           compensatingCounters.puts;
  }

  @Override
  public long getRemovals() {
    return remove.sum(EnumSet.of(StoreOperationOutcomes.RemoveOutcome.REMOVED)) +
           compute.sum(EnumSet.of(StoreOperationOutcomes.ComputeOutcome.REMOVED)) +
           conditionalRemove.sum(EnumSet.of(StoreOperationOutcomes.ConditionalRemoveOutcome.REMOVED)) -
           compensatingCounters.removals;
  }

  @Override
  public long getEvictions() {
    return eviction.sum(EnumSet.of(TierOperationOutcomes.EvictionOutcome.SUCCESS)) -
      compensatingCounters.evictions;
  }

  @Override
  public long getExpirations() {
    return expiration.sum() - compensatingCounters.expirations;
  }

  @Override
  public long getMappings() {
    return mapping.map(ValueStatistic::value).orElse(-1L);
  }

  @Override
  public long getAllocatedByteSize() {
    return allocatedMemory.map(ValueStatistic::value).orElse(-1L);
  }

  @Override
  public long getOccupiedByteSize() {
    return occupiedMemory.map(ValueStatistic::value).orElse(-1L);
  }

  private static class CompensatingCounters {
    final long hits;
    final long misses;
    final long puts;
    final long removals;
    final long evictions;
    final long expirations;

    private CompensatingCounters(long hits, long misses, long puts, long removals, long evictions, long expirations) {
      this.hits = hits;
      this.misses = misses;
      this.puts = puts;
      this.removals = removals;
      this.evictions = evictions;
      this.expirations = expirations;
    }

    static CompensatingCounters empty() {
      return new CompensatingCounters(0, 0, 0, 0, 0, 0);
    }

    CompensatingCounters snapshot(DefaultTierStatistics statistics) {
      return new CompensatingCounters(
        statistics.getHits() + hits,
        statistics.getMisses() + misses,
        statistics.getPuts() + puts,
        statistics.getRemovals() + removals,
        statistics.getEvictions() + evictions,
        statistics.getExpirations() + expirations
      );
    }
  }
}