def __init__(self, os, java_runtime, java_threading, dbms_components,
dbms_kernel, dbms_config):
if os:
self.os = Product(os[u"Name"], os[u"Version"], arch=os[u"Arch"])
self.available_processors = Amount(os[u"AvailableProcessors"])
self.process_cpu_time = Time(ns=os[u"ProcessCpuTime"])
self.process_cpu_load = Load(os[u"ProcessCpuLoad"])
self.system_cpu_load = Load(os[u"SystemCpuLoad"])
self.system_load_average = Load(os[u"SystemLoadAverage"])
if java_runtime:
self.jvm = Product(java_runtime[u"VmName"],
java_runtime[u"SpecVersion"],
uptime=Time(ms=java_runtime[u"Uptime"]))
if java_threading:
self.daemon_thread_count = Amount(
java_threading[u"DaemonThreadCount"])
self.peak_thread_count = Amount(java_threading[u"PeakThreadCount"])
self.thread_count = Amount(java_threading[u"ThreadCount"])
self.total_started_thread_count = Amount(
java_threading[u"TotalStartedThreadCount"])
if dbms_components:
t0 = dbms_kernel[u"KernelStartTime"]
t1 = 1000 * datetime.now().timestamp()
dbms_component = dbms_components[0]
dbms_component_name = dbms_component[u"name"]
if dbms_component_name == "Neo4j Kernel":
dbms_component_name = "Neo4j"
self.dbms = Product(
dbms_component_name,
dbms_component[u"versions"][0],
edition=self._editions[dbms_component[u"edition"]],
mode=dbms_config.get(u"dbms.mode", u"SINGLE"),
uptime=(Time(ms=(t1 - t0))))
def __init__(self, page_cache):
"""
{'BytesRead': 147542,
'BytesWritten': 8192,
'EvictionExceptions': 0,
'Evictions': 0,
'Faults': 19,
'FileMappings': 36,
'FileUnmappings': 19,
'Flushes': 1,
'HitRatio': 0.5777777777777777,
'Hits': 26,
'Pins': 71,
'Unpins': 44,
'UsageRatio': 1.2406315990174198e-05}
"""
self.bytes_read = BytesAmount(page_cache[u"BytesRead"])
self.bytes_written = BytesAmount(page_cache[u"BytesWritten"])
self.eviction_exceptions = Amount(page_cache[u"EvictionExceptions"])
self.evictions = Amount(page_cache[u"Evictions"])
self.faults = Amount(page_cache[u"Faults"])
self.file_mappings = Amount(page_cache[u"FileMappings"])
self.file_unmappings = Amount(page_cache[u"FileUnmappings"])
self.flushes = Amount(page_cache[u"Flushes"])
self.hit_ratio = page_cache[u"HitRatio"]
self.hits = Amount(page_cache.get(u"Hits"))
self.pins = Amount(page_cache[u"Pins"])
self.unpins = Amount(page_cache.get(u"Unpins"))
self.usage_ratio = page_cache.get(u"UsageRatio")
def __init__(self, transaction):
"""
{'transactionId': 'transaction-96',
'username': '******',
'metaData': {},
'startTime': '2018-10-18T11:04:17.938Z',
'protocol': 'bolt',
'clientAddress': '127.0.0.1:41758',
'requestUri': '127.0.0.1:17100',
'currentQueryId': 'query-127',
'currentQuery': 'CALL dbms.listTransactions',
'activeLockCount': 0,
'status': 'Running',
'resourceInformation': {},
'elapsedTimeMillis': 2,
'cpuTimeMillis': 0,
'waitTimeMillis': 0,
'idleTimeMillis': 2,
'allocatedBytes': 0,
'allocatedDirectBytes': 0,
'pageHits': 0,
'pageFaults': 0}
"""
self.id = int(transaction[u"transactionId"].partition("-")[-1])
self.user = transaction[u"username"]
self.metadata = transaction[u"metaData"]
self.start_time = transaction[u"startTime"] # TODO: unit
self.protocol = transaction[u"protocol"]
self.client_address = transaction[u"clientAddress"]
self.request_uri = transaction[u"requestUri"]
self.current_query_id_string = transaction[u"currentQueryId"]
if self.current_query_id_string:
self.current_query_id = int(
self.current_query_id_string.partition("-")[-1])
else:
self.current_query_id = None
self.current_query = transaction[u"currentQuery"]
self.active_lock_count = Amount(transaction[u"activeLockCount"])
self.status = transaction[u"status"]
self.resource_information = transaction[u"resourceInformation"]
self.elapsed_time = Time(ms=transaction[u"elapsedTimeMillis"])
self.cpu_time = Time(ms=transaction[u"cpuTimeMillis"])
self.wait_time = Time(ms=transaction[u"waitTimeMillis"])
self.idle_time = Time(ms=transaction[u"idleTimeMillis"])
self.allocated_bytes = BytesAmount(transaction[u"allocatedBytes"])
self.allocated_direct_bytes = BytesAmount(
transaction[u"allocatedDirectBytes"])
self.page_hits = Amount(transaction[u"pageHits"])
self.page_faults = Amount(transaction[u"pageFaults"])
def __init__(self, query):
"""
'activeLockCount': 0,
'allocatedBytes': None,
'clientAddress': '127.0.0.1:46718',
'cpuTimeMillis': None,
'elapsedTimeMillis': 0,
'idleTimeMillis': None,
'indexes': [],
'metaData': {},
'pageFaults': 0,
'pageHits': 0,
'parameters': {},
'planner': 'idp',
'protocol': 'bolt',
'query': 'CALL dbms.listQueries',
'queryId': 'query-64',
'requestUri': '127.0.0.1:7687',
'resourceInformation': {},
'runtime': 'procedure',
'startTime': '2018-07-13T14:06:55.851Z',
'status': 'running',
'username': '******',
'waitTimeMillis': 0,
:param query:
"""
self.active_lock_count = Amount(query[u"activeLockCount"])
self.allocated_bytes = BytesAmount(query[u"allocatedBytes"])
self.client_address = query[u"clientAddress"]
self.cpu_time = Time(ms=query[u"cpuTimeMillis"])
self.elapsed_time = Time(ms=query[u"elapsedTimeMillis"])
self.idle_time = Time(ms=query[u"idleTimeMillis"])
self.wait_time = Time(ms=query[u"waitTimeMillis"])
self.indexes = query[u"indexes"]
self.metadata = query[u"metaData"]
self.page_faults = Amount(query[u"pageFaults"])
self.page_hits = Amount(query[u"pageHits"])
self.parameters = query[u"parameters"]
self.planner = query[u"planner"]
self.protocol = query[u"protocol"]
self.text = query[u"query"]
self.request_uri = query[u"requestUri"]
self.resource_information = query[u"resourceInformation"]
self.runtime = query[u"runtime"]
self.start_time = query[u"startTime"] # TODO: unit
self.status = query[u"status"]
self.user = query[u"username"]
self.id = int(query[u"queryId"].partition("-")[-1])
def __init__(self, os, dbms_kernel, dbms_stores, dbms_primitives):
"""
MaxFileDescriptorCount: 40000
OpenFileDescriptorCount: 515
"""
self.max_file_descriptor_count = Amount(os[u"MaxFileDescriptorCount"])
self.open_file_descriptor_count = Amount(
os[u"OpenFileDescriptorCount"])
self.database_name = dbms_kernel[u"DatabaseName"]
self.read_only = dbms_kernel[u"ReadOnly"]
self.store_creation_date = dbms_kernel[u"StoreCreationDate"] # TODO
self.store_id = dbms_kernel[u"StoreId"]
self.array_store_size = BytesAmount(dbms_stores[u"ArrayStoreSize"])
self.count_store_size = BytesAmount(dbms_stores[u"CountStoreSize"])
self.index_store_size = BytesAmount(dbms_stores[u"IndexStoreSize"])
self.label_store_size = BytesAmount(dbms_stores[u"LabelStoreSize"])
self.node_store_size = BytesAmount(dbms_stores[u"NodeStoreSize"])
self.property_store_size = BytesAmount(
dbms_stores[u"PropertyStoreSize"])
self.relationship_store_size = BytesAmount(
dbms_stores[u"RelationshipStoreSize"])
self.schema_store_size = BytesAmount(dbms_stores[u"SchemaStoreSize"])
self.string_store_size = BytesAmount(dbms_stores[u"StringStoreSize"])
self.total_store_size = BytesAmount(dbms_stores[u"TotalStoreSize"])
self.transaction_logs_size = BytesAmount(
dbms_stores[u"TransactionLogsSize"])
self.node_id_count = Amount(dbms_primitives[u"NumberOfNodeIdsInUse"])
self.property_id_count = Amount(
dbms_primitives[u"NumberOfPropertyIdsInUse"])
self.relationship_id_count = Amount(
dbms_primitives[u"NumberOfRelationshipIdsInUse"])
self.relationship_type_id_count = Amount(
dbms_primitives[u"NumberOfRelationshipTypeIdsInUse"])
def __init__(self, transactions, metadata):
"""
{'LastCommittedTxId': 1,
'NumberOfCommittedTransactions': 1312,
'NumberOfOpenTransactions': 1,
'NumberOfOpenedTransactions': 1321,
'NumberOfRolledBackTransactions': 8,
'PeakNumberOfConcurrentTransactions': 2}
:param transactions:
:param metadata:
"""
if transactions is None:
self.__items = []
else:
self.__items = list(map(TransactionData, transactions))
self.last_committed_id = metadata[u"LastCommittedTxId"]
self.begin_count = Amount(metadata[u"NumberOfOpenedTransactions"])
self.open_count = Amount(metadata[u"NumberOfOpenTransactions"])
self.commit_count = Amount(metadata[u"NumberOfCommittedTransactions"])
self.rollback_count = Amount(
metadata[u"NumberOfRolledBackTransactions"])
self.peak_concurrent = Amount(
metadata[u"PeakNumberOfConcurrentTransactions"])