"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "salt/returners/appoptics_return.py" between
salt-3002.1.tar.gz and salt-3002.2.tar.gz

About: SaltStack is a systems management software for data center automation, cloud orchestration, server provisioning, configuration management and more. Community version.

appoptics_return.py  (salt-3002.1):appoptics_return.py  (salt-3002.2)
# -*- coding: utf-8 -*-
"""Salt returner to return highstate stats to AppOptics Metrics """Salt returner to return highstate stats to AppOptics Metrics
To enable this returner the minion will need the AppOptics Metrics To enable this returner the minion will need the AppOptics Metrics
client importable on the Python path and the following client importable on the Python path and the following
values configured in the minion or master config. values configured in the minion or master config.
The AppOptics python client can be found at: The AppOptics python client can be found at:
https://github.com/appoptics/python-appoptics-metrics https://github.com/appoptics/python-appoptics-metrics
skipping to change at line 69 skipping to change at line 68
This will report success and failure counts on runs of the This will report success and failure counts on runs of the
``role_salt_master.netapi``, ``role_redis.config``, and ``role_salt_master.netapi``, ``role_redis.config``, and
``role_smarty.dummy`` states in addition to highstates. ``role_smarty.dummy`` states in addition to highstates.
This will report the same metrics as above, but for these runs the This will report the same metrics as above, but for these runs the
metrics will be tagged with ``state_type: sls`` and ``state_name`` set to metrics will be tagged with ``state_type: sls`` and ``state_name`` set to
the name of the state that was invoked, e.g. ``role_salt_master.netapi``. the name of the state that was invoked, e.g. ``role_salt_master.netapi``.
""" """
# Import python libs
from __future__ import absolute_import, print_function, unicode_literals
import logging import logging
import salt.returners import salt.returners
# Import Salt libs
import salt.utils.jid import salt.utils.jid
# Import third party libs
try: try:
import appoptics_metrics import appoptics_metrics
HAS_APPOPTICS = True HAS_APPOPTICS = True
except ImportError: except ImportError:
HAS_APPOPTICS = False HAS_APPOPTICS = False
# Define the module's Virtual Name # Define the module's Virtual Name
__virtualname__ = "appoptics" __virtualname__ = "appoptics"
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
def __virtual__(): def __virtual__():
if not HAS_APPOPTICS: if not HAS_APPOPTICS:
log.error(
"The appoptics_return module couldn't load the appoptics_metrics mod
ule."
)
log.error("please make sure it is installed and is in the PYTHON_PATH.")
return ( return (
False, False,
"Could not import appoptics_metrics module; " "Could not import appoptics_metrics module; "
"appoptics-metrics python client is not installed.", "appoptics-metrics python client is not installed.",
) )
return __virtualname__ return __virtualname__
def _get_options(ret=None): def _get_options(ret=None):
""" """
Get the appoptics options from salt. Get the appoptics options from salt.
skipping to change at line 126 skipping to change at line 115
_options = salt.returners.get_returner_options( _options = salt.returners.get_returner_options(
__virtualname__, ret, attrs, __salt__=__salt__, __opts__=__opts__ __virtualname__, ret, attrs, __salt__=__salt__, __opts__=__opts__
) )
_options["api_url"] = _options.get("api_url", "api.appoptics.com") _options["api_url"] = _options.get("api_url", "api.appoptics.com")
_options["sls_states"] = _options.get("sls_states", []) _options["sls_states"] = _options.get("sls_states", [])
_options["tags"] = _options.get( _options["tags"] = _options.get(
"tags", {"host_hostname_alias": __salt__["grains.get"]("id")} "tags", {"host_hostname_alias": __salt__["grains.get"]("id")}
) )
log.debug("Retrieved appoptics options: {}".format(_options)) log.debug("Retrieved appoptics options: %s", _options)
return _options return _options
def _get_appoptics(options): def _get_appoptics(options):
""" """
Return an appoptics connection object. Return an appoptics connection object.
""" """
conn = appoptics_metrics.connect( conn = appoptics_metrics.connect(
options.get("api_token"), options.get("api_token"),
sanitizer=appoptics_metrics.sanitize_metric_name, sanitizer=appoptics_metrics.sanitize_metric_name,
hostname=options.get("api_url"), hostname=options.get("api_url"),
skipping to change at line 155 skipping to change at line 144
if isinstance(resultset, dict) and "duration" in resultset: if isinstance(resultset, dict) and "duration" in resultset:
# Count the pass vs failures # Count the pass vs failures
if resultset["result"]: if resultset["result"]:
results["num_passed_states"] += 1 results["num_passed_states"] += 1
else: else:
results["num_failed_states"] += 1 results["num_failed_states"] += 1
# Count durations # Count durations
results["runtime"] += resultset["duration"] results["runtime"] += resultset["duration"]
log.debug("Parsed state metrics: {}".format(results)) log.debug("Parsed state metrics: %s", results)
return results return results
def _state_metrics(ret, options, tags): def _state_metrics(ret, options, tags):
# Calculate the runtimes and number of failed states. # Calculate the runtimes and number of failed states.
stats = _calculate_runtimes(ret["return"]) stats = _calculate_runtimes(ret["return"])
log.debug("Batching Metric retcode with {}".format(ret["retcode"])) log.debug("Batching Metric retcode with %s", ret["retcode"])
appoptics_conn = _get_appoptics(options) appoptics_conn = _get_appoptics(options)
q = appoptics_conn.new_queue(tags=tags) q = appoptics_conn.new_queue(tags=tags)
q.add("saltstack.retcode", ret["retcode"]) q.add("saltstack.retcode", ret["retcode"])
log.debug( log.debug("Batching Metric num_failed_jobs with %s", stats["num_failed_state
"Batching Metric num_failed_jobs with {}".format(stats["num_failed_state s"])
s"])
)
q.add("saltstack.failed", stats["num_failed_states"]) q.add("saltstack.failed", stats["num_failed_states"])
log.debug( log.debug("Batching Metric num_passed_states with %s", stats["num_passed_sta
"Batching Metric num_passed_states with {}".format(stats["num_passed_sta tes"])
tes"])
)
q.add("saltstack.passed", stats["num_passed_states"]) q.add("saltstack.passed", stats["num_passed_states"])
log.debug("Batching Metric runtime with {}".format(stats["runtime"])) log.debug("Batching Metric runtime with %s".stats["runtime"])
q.add("saltstack.runtime", stats["runtime"]) q.add("saltstack.runtime", stats["runtime"])
log.debug( log.debug(
"Batching with Metric total states {}".format( "Batching with Metric total states %s",
(stats["num_failed_states"] + stats["num_passed_states"]) stats["num_failed_states"] + stats["num_passed_states"],
)
) )
q.add( q.add(
"saltstack.highstate.total_states", "saltstack.highstate.total_states",
(stats["num_failed_states"] + stats["num_passed_states"]), (stats["num_failed_states"] + stats["num_passed_states"]),
) )
log.info("Sending metrics to appoptics.") log.info("Sending metrics to appoptics.")
q.submit() q.submit()
def returner(ret): def returner(ret):
""" """
skipping to change at line 206 skipping to change at line 190
the result of that state if it's present. the result of that state if it's present.
""" """
options = _get_options(ret) options = _get_options(ret)
states_to_report = ["state.highstate"] states_to_report = ["state.highstate"]
if options.get("sls_states"): if options.get("sls_states"):
states_to_report.append("state.sls") states_to_report.append("state.sls")
if ret["fun"] in states_to_report: if ret["fun"] in states_to_report:
tags = options.get("tags", {}).copy() tags = options.get("tags", {}).copy()
tags["state_type"] = ret["fun"] tags["state_type"] = ret["fun"]
log.info("Tags for this run are {}".format(str(tags))) log.info("Tags for this run are %s", str(tags))
matched_states = set(ret["fun_args"]).intersection( matched_states = set(ret["fun_args"]).intersection(
set(options.get("sls_states", [])) set(options.get("sls_states", []))
) )
# What can I do if a run has multiple states that match? # What can I do if a run has multiple states that match?
# In the mean time, find one matching state name and use it. # In the mean time, find one matching state name and use it.
if matched_states: if matched_states:
tags["state_name"] = sorted(matched_states)[0] tags["state_name"] = sorted(matched_states)[0]
log.debug("Found returned data from {}.".format(tags["state_name"])) log.debug("Found returned data from %s.", tags["state_name"])
_state_metrics(ret, options, tags) _state_metrics(ret, options, tags)
 End of changes. 14 change blocks. 
29 lines changed or deleted 12 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)