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 _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 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())