def add_metric(self, category, counter, instance, value, log_event=False):
"""
Create and save an event which contains a telemetry event.
:param str category: The category of metric (e.g. "cpu", "memory")
:param str counter: The specific metric within the category (e.g. "%idle")
:param str instance: For instanced metrics, the instance identifier (filesystem name, cpu core#, etc.)
:param value: Value of the metric
:param bool log_event: If true, log the collected metric in the agent log
"""
if log_event:
message = "Metric {0}/{1} [{2}] = {3}".format(category, counter, instance, value)
_log_event(AGENT_NAME, "METRIC", message, 0)
event = TelemetryEvent(TELEMETRY_METRICS_EVENT_ID, TELEMETRY_EVENT_PROVIDER_ID)
event.parameters.append(TelemetryEventParam(GuestAgentPerfCounterEventsSchema.Category, str(category)))
event.parameters.append(TelemetryEventParam(GuestAgentPerfCounterEventsSchema.Counter, str(counter)))
event.parameters.append(TelemetryEventParam(GuestAgentPerfCounterEventsSchema.Instance, str(instance)))
event.parameters.append(TelemetryEventParam(GuestAgentPerfCounterEventsSchema.Value, float(value)))
self.add_common_event_parameters(event, datetime.utcnow())
data = get_properties(event)
try:
self.save_event(json.dumps(data))
except EventError as e:
logger.periodic_error(logger.EVERY_FIFTEEN_MINUTES, "[PERIODIC] {0}".format(ustr(e)))
def run_get_output(cmd, chk_err=True, log_cmd=True, expected_errors=[]):
"""
Wrapper for subprocess.check_output.
Execute 'cmd'. Returns return code and STDOUT, trapping expected
exceptions.
Reports exceptions to Error if chk_err parameter is True
"""
if log_cmd:
logger.verbose(u"Command: [{0}]", cmd)
try:
output = subprocess.check_output(cmd,
stderr=subprocess.STDOUT,
shell=True)
output = ustr(output,
encoding='utf-8',
errors="backslashreplace")
except subprocess.CalledProcessError as e:
output = ustr(e.output,
encoding='utf-8',
errors="backslashreplace")
if chk_err:
msg = u"Command: [{0}], " \
u"return code: [{1}], " \
u"result: [{2}]".format(cmd, e.returncode, output)
if e.returncode in expected_errors:
logger.periodic_info(logger.EVERY_FIFTEEN_MINUTES, msg)
else:
logger.periodic_error(logger.EVERY_FIFTEEN_MINUTES, msg)
return e.returncode, output
except Exception as e:
if chk_err:
logger.error(u"Command [{0}] raised unexpected exception: [{1}]"
.format(cmd, ustr(e)))
return -1, ustr(e)
return 0, output
def add_event(self,
name,
op=WALAEventOperation.Unknown,
is_success=True,
duration=0,
version=str(CURRENT_VERSION),
message="",
log_event=True):
if (not is_success) and log_event:
_log_event(name, op, message, duration, is_success=is_success)
event = TelemetryEvent(TELEMETRY_EVENT_EVENT_ID,
TELEMETRY_EVENT_PROVIDER_ID)
event.parameters.append(TelemetryEventParam('Name', str(name)))
event.parameters.append(TelemetryEventParam('Version', str(version)))
event.parameters.append(TelemetryEventParam('Operation', str(op)))
event.parameters.append(
TelemetryEventParam('OperationSuccess', bool(is_success)))
event.parameters.append(TelemetryEventParam('Message', str(message)))
event.parameters.append(TelemetryEventParam('Duration', int(duration)))
self._add_common_event_parameters(event, datetime.utcnow())
data = get_properties(event)
try:
self.save_event(json.dumps(data))
except EventError as e:
logger.periodic_error(logger.EVERY_FIFTEEN_MINUTES,
"[PERIODIC] {0}".format(ustr(e)))
def test_periodic_does_not_emit_if_previously_sent(self, mock_info, mock_error, mock_warn, mock_verbose):
# The count does not increase from 1 - the first time it sends the data.
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, *_DATA)
self.assertIn(hash(_MSG_INFO), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_info.call_count)
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, *_DATA)
self.assertIn(hash(_MSG_INFO), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_info.call_count)
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, *_DATA)
self.assertIn(hash(_MSG_WARN), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_warn.call_count)
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, *_DATA)
self.assertIn(hash(_MSG_WARN), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_warn.call_count)
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, *_DATA)
self.assertIn(hash(_MSG_ERROR), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_error.call_count)
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, *_DATA)
self.assertIn(hash(_MSG_ERROR), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_error.call_count)
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, *_DATA)
self.assertIn(hash(_MSG_VERBOSE), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_verbose.call_count)
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, *_DATA)
self.assertIn(hash(_MSG_VERBOSE), logger.DEFAULT_LOGGER.periodic_messages)
self.assertEqual(1, mock_verbose.call_count)
self.assertEqual(4, len(logger.DEFAULT_LOGGER.periodic_messages))
def test_periodic_emits_if_not_previously_sent(self, mock_info, mock_error, mock_warn, mock_verbose):
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, logger.LogLevel.INFO, *_DATA)
self.assertEqual(1, mock_info.call_count)
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, logger.LogLevel.ERROR, *_DATA)
self.assertEqual(1, mock_error.call_count)
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, logger.LogLevel.WARNING, *_DATA)
self.assertEqual(1, mock_warn.call_count)
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, logger.LogLevel.VERBOSE, *_DATA)
self.assertEqual(1, mock_verbose.call_count)
def test_periodic_forwards_message_and_args(self, mock_info, mock_error, mock_warn, mock_verbose):
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, *_DATA)
mock_info.assert_called_once_with(_MSG_INFO, *_DATA)
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, *_DATA)
mock_error.assert_called_once_with(_MSG_ERROR, *_DATA)
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, *_DATA)
mock_warn.assert_called_once_with(_MSG_WARN, *_DATA)
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, *_DATA)
mock_verbose.assert_called_once_with(_MSG_VERBOSE, *_DATA)
def _add_event(self, duration, evt_type, is_internal, is_success, message,
name, op, version, event_id):
event = TelemetryEvent(event_id, TELEMETRY_EVENT_PROVIDER_ID)
event.parameters.append(TelemetryEventParam('Name', name))
event.parameters.append(TelemetryEventParam('Version', str(version)))
event.parameters.append(TelemetryEventParam('IsInternal', is_internal))
event.parameters.append(TelemetryEventParam('Operation', op))
event.parameters.append(
TelemetryEventParam('OperationSuccess', is_success))
event.parameters.append(TelemetryEventParam('Message', message))
event.parameters.append(TelemetryEventParam('Duration', duration))
event.parameters.append(TelemetryEventParam('ExtensionType', evt_type))
self.add_default_parameters_to_event(event)
data = get_properties(event)
try:
self.save_event(json.dumps(data))
except EventError as e:
logger.periodic_error(logger.EVERY_FIFTEEN_MINUTES,
"[PERIODIC] {0}".format(ustr(e)))
def test_periodic_emits_after_elapsed_delta(self, mock_info, mock_error,
mock_warn, mock_verbose):
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, *_DATA)
self.assertEqual(1, mock_info.call_count)
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, *_DATA)
self.assertEqual(1, mock_info.call_count)
logger.DEFAULT_LOGGER.periodic_messages[hash(_MSG_INFO)] = datetime.now() - \
logger.EVERY_DAY - logger.EVERY_HOUR
logger.periodic_info(logger.EVERY_DAY, _MSG_INFO, *_DATA)
self.assertEqual(2, mock_info.call_count)
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, *_DATA)
self.assertEqual(1, mock_warn.call_count)
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, *_DATA)
self.assertEqual(1, mock_warn.call_count)
logger.DEFAULT_LOGGER.periodic_messages[hash(_MSG_WARN)] = datetime.now() - \
logger.EVERY_DAY - logger.EVERY_HOUR
logger.periodic_warn(logger.EVERY_DAY, _MSG_WARN, *_DATA)
self.assertEqual(2, mock_info.call_count)
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, *_DATA)
self.assertEqual(1, mock_error.call_count)
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, *_DATA)
self.assertEqual(1, mock_error.call_count)
logger.DEFAULT_LOGGER.periodic_messages[hash(_MSG_ERROR)] = datetime.now() - \
logger.EVERY_DAY - logger.EVERY_HOUR
logger.periodic_error(logger.EVERY_DAY, _MSG_ERROR, *_DATA)
self.assertEqual(2, mock_info.call_count)
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, *_DATA)
self.assertEqual(1, mock_verbose.call_count)
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, *_DATA)
self.assertEqual(1, mock_verbose.call_count)
logger.DEFAULT_LOGGER.periodic_messages[hash(_MSG_VERBOSE)] = datetime.now() - \
logger.EVERY_DAY - logger.EVERY_HOUR
logger.periodic_verbose(logger.EVERY_DAY, _MSG_VERBOSE, *_DATA)
self.assertEqual(2, mock_info.call_count)
