def __init__(self, label, y_axis, palette_index, plot_type, display_name):
"""Initializes and validates publish label options.
Arguments:
label: label used in the publish statement that displayes the plot
y_axis: the y-axis associated with values for this plot.
Must be 0 (left) or 1 (right).
palette_index: the indexed palette color to use for all plot lines
plot_type: the visualization style to use
display_name: an alternate name to show in the legend
"""
for arg in [label, display_name]:
util.is_valid(arg)
util.in_given_enum(palette_index, PaletteColor)
util.in_given_enum(plot_type, PlotType)
if y_axis not in [0, 1]:
msg = "YAxis for chart must be 0 (Left) or 1 (Right); " +\
"'{0}' provided."
raise ValueError(msg.format(y_axis))
self.opts = {
'label': label,
'yAxis': y_axis,
'paletteIndex': palette_index.value,
'plotType': plot_type.value,
'displayName': display_name
}
def with_program_options(self,
min_resolution,
max_delay,
disable_sampling=False):
"""How should the program underlying the visualization be run.
Arguments:
min_resolution: min resolution to use for computing program
max_delay: How long to wait for late datapoints, in ms.
disable_sampling: samples a subset of output MTS unless enabled.
Improves chart performance for heavier MTS.
Consult this page for more information on min resolution:
https://docs.signalfx.com/en/latest/reference/analytics-docs/how-choose-data-resolution.html
Consult this page for more information on late datapoints:
https://docs.signalfx.com/en/latest/charts/chart-options-tab.html#max-delay
Returns:
This TimeSeriesChart with program options.
"""
util.is_valid(min_resolution)
util.is_valid(max_delay)
program_opts = {
'minimumResolution': min_resolution,
'maxDelay': max_delay,
'disableSampling': disable_sampling
}
self.chart_options.update({'programOptions': program_opts})
return self
def with_id(self, ident):
"""The id for this resource.
Useful for creates/deletes.
"""
util.is_valid(ident)
self.options.update({'id': ident})
return self
def with_id(self, id):
"""The unique identifier for this chart.
Useful when updating/deleting charts.
"""
util.is_valid(id)
self.options.update({'id': id})
return self
def with_parameterized_subject(self, subject):
"""Custom notification message subject for this rule when an alert is
triggered.
See the documentation for `with_parameterized_body` for more detail.
"""
util.is_valid(subject)
self.options.update({'parameterizedSubject': subject})
return self
def with_runbook_url(self, url):
"""URL of the page to consult when an alert is triggered.
This can be used with custom notification messages. It can be
referenced using the {{runbookUrl}} template var.
"""
util.is_valid(url)
self.options.update({'runbookUrl': url})
return self
def __set_api_token__(self, token):
"""Internal helper for setting valid API tokens."""
message = """Cannot proceed with an empty API token.
Either pass one in at Resource instantiation time or provide one
via the `with_api_token` method."""
util.is_valid(token, message)
self.api_token = token
def with_tip(self, tip):
"""Plain text suggested first course of action, such as a command line
to execute.
This can be used with custom notification messages. It can be
referenced using the {{tip}} template var.
"""
util.is_valid(tip)
self.options.update({'tip': tip})
return self
def with_axes(self, axes):
"""Options for labeling axes on TimeSeries charts.
Don't leave your axes laying about or this guy might show up:
https://youtu.be/V2FygG84bg8
"""
util.is_valid(axes)
self.chart_options.update(
{'axes': list(map(lambda x: x.to_dict(), axes))})
return self
def with_program(self, program):
"""The SignalFlow program to execute for this chart.
For more information SignalFlow consult the `signal_analog.flow`
module or the upstream SignalFlow documentation here:
https://developers.signalfx.com/docs/signalflow-overview
"""
util.is_valid(program)
self.options.update({'programText': program})
return self
def __init__(self, team_id):
"""Initializes a new team e-mail notification.
No validation is done to verify that a team id exists in SignalFx.
Arguments:
team_id: the id of the team to e-mail.
"""
util.is_valid(team_id)
self.options = {'type': 'TeamEmail', 'team': team_id}
def with_colorscale(self, thresholds):
"""Values for each color in the range.
Arguments:
thresholds: The thresholds to set for the color range being used.
"""
util.is_valid(thresholds)
thresholds.sort(reverse=True)
opts = {'thresholds': thresholds}
self.chart_options.update({'colorScale': opts})
return self
def __init__(self, sn_id):
"""Initializes a new ServiceNow notification.
This does not setup a ServiceNow integration for you, one must already
exist before using this notification type. No validation is done to
ensure that a ServiceNow integration id is valid.
Arguments:
sn_id: the ServiceNow integration id to use
"""
util.is_valid(sn_id)
self.options = {'type': 'ServiceNow', 'credentialId': sn_id}
def with_time_config_relative(self, range):
"""Options to set the relative view window into the given chart.
Arguments:
range: Absolute millisecond offset from now to visualize.
Returns:
This TimeSeriesChart with absolute time config
"""
util.is_valid(range)
opts = {'type': 'relative', 'range': range}
self.chart_options.update({'time': opts})
return self
def with_colorscale(self, thresholds, inverted=False):
"""Values for each color in the range.
Arguments:
thresholds: The thresholds to set for the color range being used.
inverted: If false, values are red if they are above
the highest specified value. If true, values are red if
they are below the lowest specified value.
"""
util.is_valid(thresholds)
thresholds.sort(reverse=True)
opts = {'thresholds': thresholds, 'inverted': inverted}
self.chart_options.update({'colorScale': opts})
return self
def with_parameterized_body(self, body):
"""Custom notifiction message body for this rule when the alert is
triggeered.
Content can contain ASCII chars and is parsed as plain text. Quotes
can be escaped using a backslash, and new line characters are
indicated with "\\n"
Available variables can be found here:
https://docs.signalfx.com/en/latest/detect-alert/set-up-detectors.html#message-variables
"""
util.is_valid(body)
self.options.update({'parameterizedBody': body})
return self
def with_time_config_absolute(self, start, end):
"""Options to set the absolute view window into the given chart.
Arguments:
start: Milliseconds since epoch to start the visualization.
end: Milliseconds since epoch to end the visualization.
Returns:
This TimeSeriesChart with a relative time config.
"""
util.is_valid(start)
util.is_valid(end)
opts = {'type': 'absolute', 'start': start, 'end': end}
self.chart_options.update({'time': opts})
return self
def __init__(self, url, secret=None):
"""Initializes a new webhook notification.
Arguments:
url: the URL to call back
secret: optional, when provided the request will contain a
`X-SFX-Signature` header containing the Base64 encoded
HMAC-SHA1 digest of the request body using the shared
secret.
"""
util.is_valid(url)
self.options = {'type': 'Webhook', 'url': url}
if secret:
self.options.update({'secret': secret})
def __init__(self, pd_id):
"""Initializes a new PagerDuty notification.
This does not setup a PagerDuty integration for you, one must already
exist before using this notification type. No validation is done to
ensure that a PD integration id is valid.
These values will typically differ depending on the on-call rotation
you want to add to the detector.
See the integration page for more detail:
https://developers.signalfx.com/v2/reference#pagerduty-integration-model
Arguments:
pd_id: the id of the PagerDuty integration to include.
"""
util.is_valid(pd_id)
self.options = {'type': 'PagerDuty', 'credentialId': pd_id}
def __init__(self, vo_id, routing_key):
"""Initializes a new VictorOps notification.
This does not setup a VictorOps integration for you, one must already
exist before using this notification type. No validation is done to
ensure that a VictorOps integration id is valid.
Arguments:
vo_id: the VictorOps integration id to use
routing_key: a VictorOps routing key
"""
util.is_valid(vo_id)
util.is_valid(routing_key)
self.options = {
'type': 'VictorOps',
'credentialId': vo_id,
'routingKey': routing_key
}
def __init__(self, slack_id, channel_name):
"""Initializes a new Slack notification rule.
This does not setup a Slack integration for you, one must already exist
before using this notification type. No validation is done to ensure
that a Slack integration id is valid.
See the integration page for more detail:
https://developers.signalfx.com/v2/reference#slack-integration-model
Arguments:
slack_id: the slack integration id to use
channel_name: the name of the channel to send alerts to
"""
util.is_valid(slack_id)
util.is_valid(channel_name)
self.options = {
'type': 'Slack',
'credentialId': slack_id,
'channel': channel_name
}
def __init__(self, hp_id, room_name):
"""Initializes a new HipChat notification.
This does not setup a Slack integration for you, one must already exist
before using this notification type. No validation is done to ensure
that a HipChat integration id is valid.
See the integration page for more detail:
https://developers.signalfx.com/v2/reference#hipchat-integration-model
Arguments:
hp_id: the HipChat integration id to use
room_name: the HipChat room name to post integrations to
"""
util.is_valid(hp_id)
util.is_valid(room_name)
self.options = {
'type': 'HipChat',
'credentialId': hp_id,
'room': room_name
}
def with_unit_prefix(self, prefix):
"""Add a unit prefix to this chart."""
util.is_valid(prefix)
util.in_given_enum(prefix, UnitPrefix)
self.chart_options.update({'unitPrefix': prefix.value})
return self
def with_refresh_interval(self, interval):
"""How often (in milliseconds) to refresh the values of the list."""
util.is_valid(interval)
self.chart_options.update({'refreshInterval': interval})
return self
def with_maximum_precision(self, precision):
"""The maximum precision to for values displayed in the list."""
util.is_valid(precision)
self.chart_options.update({'maximumPrecision': precision})
return self
def with_publish_label_options(self, *publish_opts):
"""Plot-level customization, associated with a publish statement."""
util.is_valid(publish_opts)
opt = list(map(lambda o: o.to_dict(), publish_opts))
self.chart_options.update({'publishLabelOptions': opt})
return self
def with_chart_legend_options(self, dimension, show_legend=False):
"""Show the on-chart legend using the given dimension."""
util.is_valid(dimension)
opts = {'showLegend': show_legend, 'dimensionInLegend': dimension}
self.chart_options.update({'onChartLegendOptions': opts})
return self
def with_axis_precision(self, num):
"""Force a specific number of significant digits in the y-axis."""
util.is_valid(num)
self.chart_options.update({'axisPrecision': num})
return self
def with_default_plot_type(self, plot_type):
"""The default plot display style for the visualization."""
util.is_valid(plot_type)
util.in_given_enum(plot_type, PlotType)
self.chart_options.update({'defaultPlotType': plot_type.value})
return self
def with_legend_options(self, field_opts):
"""Options for the behavior of this chart's legend."""
util.is_valid(field_opts)
opts = {'fields': list(map(lambda x: x.to_dict(), field_opts))}
self.chart_options.update({'legendOptions': opts})
return self
