def __init__(self, key, value, create_time=None, ttl_seconds=None):
self.key = key
self.value = value
self.create_time = create_time if create_time is not None else current_time()
self.expiration_time = self.create_time + ttl_seconds if ttl_seconds is not None else None
self.last_access_time = self.create_time
self.access_hit = 0
def __init__(self, name, serialization_service, in_memory_format, time_to_live_seconds, max_idle_seconds, invalidate_on_change,
eviction_policy, eviction_max_size, eviction_sampling_count=None, eviction_sampling_pool_size=None):
self.name = name
self.serialization_service = serialization_service
self.in_memory_format = in_memory_format
self.time_to_live_seconds = time_to_live_seconds
self.max_idle_seconds = max_idle_seconds
self.invalidate_on_change = invalidate_on_change
self.eviction_policy = eviction_policy
self.eviction_max_size = eviction_max_size
if eviction_sampling_count is None: # None or zero
self.eviction_sampling_count = max(eviction_max_size // 10, 1)
elif 0 < eviction_sampling_count <= self.eviction_max_size:
self.eviction_sampling_count = eviction_sampling_count
else:
self.eviction_sampling_count = self.eviction_max_size
if eviction_sampling_pool_size is None: # None or zero
self.eviction_sampling_pool_size = max(eviction_max_size // 5, 1)
elif 0 < eviction_sampling_pool_size <= self.eviction_max_size:
self.eviction_sampling_pool_size = eviction_sampling_pool_size
else:
self.eviction_sampling_pool_size = self.eviction_max_size
# internal
self._key_func = eviction_key_func[self.eviction_policy]
self._eviction_candidates = list()
self._evictions = 0
self._expirations = 0
self._hits = 0
self._misses = 0
self._invalidations = 0
self._invalidation_requests = 0
self._creation_time_in_seconds = current_time()
def __init__(self, key, value, create_time=None, ttl_seconds=None):
self.key = key
self.value = value
self.create_time = create_time if create_time is not None else current_time()
self.expiration_time = self.create_time + ttl_seconds if ttl_seconds is not None else None
self.last_access_time = self.create_time
self.access_hit = 0
def _register_gauges(self):
if not _PSUTIL_ENABLED:
_logger.warning(
"Statistics collection is enabled, but psutil is not found. "
"Runtime and system related metrics will not be collected.")
return
self._register_system_gauge(
"os.totalPhysicalMemorySize",
lambda: psutil.virtual_memory().total,
)
self._register_system_gauge(
"os.freePhysicalMemorySize",
lambda: psutil.virtual_memory().free,
)
self._register_system_gauge(
"os.committedVirtualMemorySize",
lambda: psutil.virtual_memory().used,
)
self._register_system_gauge(
"os.totalSwapSpaceSize",
lambda: psutil.swap_memory().total,
)
self._register_system_gauge(
"os.freeSwapSpaceSize",
lambda: psutil.swap_memory().free,
)
self._register_system_gauge(
"os.systemLoadAverage",
lambda: os.getloadavg()[0],
ValueType.DOUBLE,
)
self._register_system_gauge(
"runtime.availableProcessors",
lambda: psutil.cpu_count(),
)
self._register_process_gauge(
"runtime.usedMemory",
lambda p: p.memory_info().rss,
)
self._register_process_gauge(
"os.openFileDescriptorCount",
lambda p: p.num_fds(),
)
self._register_process_gauge(
"os.maxFileDescriptorCount",
lambda p: p.rlimit(psutil.RLIMIT_NOFILE)[1],
)
self._register_process_gauge(
"os.processCpuTime",
lambda p: to_nanos(sum(p.cpu_times())),
)
self._register_process_gauge(
"runtime.uptime",
lambda p: to_millis(current_time() - p.create_time()),
)
def is_expired(self, max_idle_seconds):
"""
Determines whether this record is expired or not.
:param max_idle_seconds: (long), the maximum idle time of record, maximum time after the last access time.
:return: (bool), ``true`` is this record is not expired.
"""
now = current_time()
return (self.expiration_time is not None and self.expiration_time < now) or \
(max_idle_seconds is not None and self.last_access_time + max_idle_seconds < now)
def is_expired(self, max_idle_seconds):
"""Determines whether this record is expired or not.
Args:
max_idle_seconds (int): The maximum idle time of record, maximum time after the last access time.
Returns:
bool: ``True`` is this record is not expired, ``False`` otherwise.
"""
now = current_time()
return (self.expiration_time is not None and self.expiration_time < now) or \
(max_idle_seconds is not None and self.last_access_time + max_idle_seconds < now)
def __getitem__(self, key):
try:
value_record = super(NearCache, self).__getitem__(key)
if value_record.is_expired(self.max_idle_seconds):
super(NearCache, self).__delitem__(key)
raise KeyError
except KeyError as ke:
self._cache_miss += 1
raise ke
if self.eviction_policy == EVICTION_POLICY.LRU:
value_record.last_access_time = current_time()
elif self.eviction_policy == EVICTION_POLICY.LFU:
value_record.access_hit += 1
self._cache_hit += 1
return self.serialization_service.to_object(value_record.value) \
if self.in_memory_format == IN_MEMORY_FORMAT.BINARY else value_record.value
def __getitem__(self, key):
try:
value_record = super(NearCache, self).__getitem__(key)
if value_record.is_expired(self.max_idle):
super(NearCache, self).__delitem__(key)
raise KeyError
except KeyError as ke:
self._misses += 1
raise ke
if self.eviction_policy == EvictionPolicy.LRU:
value_record.last_access_time = current_time()
elif self.eviction_policy == EvictionPolicy.LFU:
value_record.access_hit += 1
self._hits += 1
return self.serialization_service.to_object(value_record.value) \
if self.in_memory_format == InMemoryFormat.BINARY else value_record.value
def __getitem__(self, key):
try:
value_record = super(NearCache, self).__getitem__(key)
if value_record.is_expired(self.max_idle_seconds):
super(NearCache, self).__delitem__(key)
raise KeyError
except KeyError as ke:
self._cache_miss += 1
raise ke
if self.eviction_policy == EVICTION_POLICY.LRU:
value_record.last_access_time = current_time()
elif self.eviction_policy == EVICTION_POLICY.LFU:
value_record.access_hit += 1
self._cache_hit += 1
return self.serialization_service.to_object(value_record.value) \
if self.in_memory_format == IN_MEMORY_FORMAT.BINARY else value_record.value
def is_expired(self, max_idle_seconds):
now = current_time()
return (self.expiration_time is not None and self.expiration_time < now) or \
(max_idle_seconds is not None and self.last_access_time + max_idle_seconds < now)
def next_id(self):
if self._invalid_since <= current_time():
return None
return next(self._iterator, None)
def __init__(self, id_batch, validity):
self._id_batch = id_batch
self._iterator = iter(self._id_batch)
self._invalid_since = validity + current_time(
) if validity > 0 else MAX_SIZE
def _collect_process_uptime(self, psutil_stats, probe_name, process):
return to_millis(current_time() - process.create_time())
def is_expired(self, max_idle_seconds):
now = current_time()
return (self.expiration_time is not None and self.expiration_time < now) or \
(max_idle_seconds is not None and self.last_access_time + max_idle_seconds < now)
