def test_agent_version(self):
self.assertEqual(datadog_agent.get_version(), "6.0.0")
def test_agent_version(self):
self.assertEqual(datadog_agent.get_version(), "6.0.0")
def __get_version(agentConfig):
if datadog_agent:
version = datadog_agent.get_version() or '0.0.0'
else:
version = agentConfig.get('version', '0.0.0')
return version
def _collect_plan_for_statement(self, row):
# limit the rate of explains done to the database
cache_key = (row['datname'], row['query_signature'])
if not self._explained_statements_ratelimiter.acquire(cache_key):
return None
# Plans have several important signatures to tag events with. Note that for postgres, the
# query_signature and resource_hash will be the same value.
# - `plan_signature` - hash computed from the normalized JSON plan to group identical plan trees
# - `resource_hash` - hash computed off the raw sql text to match apm resources
# - `query_signature` - hash computed from the raw sql text to match query metrics
plan_dict, explain_err_code, err_msg = self._run_and_track_explain(
row['datname'], row['query'], row['statement'],
row['query_signature'])
collection_errors = None
if explain_err_code:
collection_errors = [{
'code': explain_err_code.value,
'message': err_msg if err_msg else None
}]
plan, normalized_plan, obfuscated_plan, plan_signature = None, None, None, None
if plan_dict:
plan = json.dumps(plan_dict)
# if we're using the orjson implementation then json.dumps returns bytes
plan = plan.decode('utf-8') if isinstance(plan, bytes) else plan
normalized_plan = datadog_agent.obfuscate_sql_exec_plan(
plan, normalize=True)
obfuscated_plan = datadog_agent.obfuscate_sql_exec_plan(plan)
plan_signature = compute_exec_plan_signature(normalized_plan)
statement_plan_sig = (row['query_signature'], plan_signature)
if self._seen_samples_ratelimiter.acquire(statement_plan_sig):
event = {
"host": self._check.resolved_hostname,
"ddagentversion": datadog_agent.get_version(),
"ddsource": "postgres",
"ddtags": ",".join(self._dbtags(row['datname'])),
"timestamp": time.time() * 1000,
"network": {
"client": {
"ip": row.get('client_addr', None),
"port": row.get('client_port', None),
"hostname": row.get('client_hostname', None),
}
},
"db": {
"instance":
row.get('datname', None),
"plan": {
"definition": obfuscated_plan,
"signature": plan_signature,
"collection_errors": collection_errors,
},
"query_signature":
row['query_signature'],
"resource_hash":
row['query_signature'],
"application":
row.get('application_name', None),
"user":
row['usename'],
"statement":
row['statement'],
"metadata": {
"tables": row['dd_tables'],
"commands": row['dd_commands'],
"comments": row['dd_comments'],
},
"query_truncated":
self._get_truncation_state(
self._get_track_activity_query_size(),
row['query']).value,
},
'postgres': {
k: v
for k, v in row.items()
if k not in pg_stat_activity_sample_exclude_keys
},
}
if row['state'] in {'idle', 'idle in transaction'}:
if row['state_change'] and row['query_start']:
event['duration'] = (
row['state_change'] -
row['query_start']).total_seconds() * 1e9
# If the transaction is idle then we have a more specific "end time" than the current time at
# which we're collecting this event. According to the postgres docs, all of the timestamps in
# pg_stat_activity are `timestamp with time zone` so the timezone should always be present. However,
# if there is something wrong and it's missing then we can't use `state_change` for the timestamp
# of the event else we risk the timestamp being significantly off and the event getting dropped
# during ingestion.
if row['state_change'].tzinfo:
event['timestamp'] = get_timestamp(
row['state_change']) * 1000
return event
return None