You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
761 lines
26 KiB
761 lines
26 KiB
zabbix_export:
|
|
version: '7.0'
|
|
media_types:
|
|
-
|
|
name: Mattermost
|
|
type: WEBHOOK
|
|
parameters:
|
|
-
|
|
name: alert_message
|
|
value: '{ALERT.MESSAGE}'
|
|
-
|
|
name: alert_subject
|
|
value: '{ALERT.SUBJECT}'
|
|
-
|
|
name: bot_token
|
|
value: '<YOUR BOT TOKEN>'
|
|
-
|
|
name: discovery_host_dns
|
|
value: '{DISCOVERY.DEVICE.DNS}'
|
|
-
|
|
name: discovery_host_ip
|
|
value: '{DISCOVERY.DEVICE.IPADDRESS}'
|
|
-
|
|
name: event_date
|
|
value: '{EVENT.DATE}'
|
|
-
|
|
name: event_id
|
|
value: '{EVENT.ID}'
|
|
-
|
|
name: event_nseverity
|
|
value: '{EVENT.NSEVERITY}'
|
|
-
|
|
name: event_opdata
|
|
value: '{EVENT.OPDATA}'
|
|
-
|
|
name: event_recovery_date
|
|
value: '{EVENT.RECOVERY.DATE}'
|
|
-
|
|
name: event_recovery_time
|
|
value: '{EVENT.RECOVERY.TIME}'
|
|
-
|
|
name: event_severity
|
|
value: '{EVENT.SEVERITY}'
|
|
-
|
|
name: event_source
|
|
value: '{EVENT.SOURCE}'
|
|
-
|
|
name: event_tags
|
|
value: '{EVENT.TAGS}'
|
|
-
|
|
name: event_time
|
|
value: '{EVENT.TIME}'
|
|
-
|
|
name: event_update_date
|
|
value: '{EVENT.UPDATE.DATE}'
|
|
-
|
|
name: event_update_status
|
|
value: '{EVENT.UPDATE.STATUS}'
|
|
-
|
|
name: event_update_time
|
|
value: '{EVENT.UPDATE.TIME}'
|
|
-
|
|
name: event_value
|
|
value: '{EVENT.VALUE}'
|
|
-
|
|
name: host_ip
|
|
value: '{HOST.IP}'
|
|
-
|
|
name: host_name
|
|
value: '{HOST.HOST}'
|
|
-
|
|
name: mattermost_url
|
|
value: '<YOUR MATTERMOST URL>'
|
|
-
|
|
name: send_mode
|
|
value: alarm
|
|
-
|
|
name: send_to
|
|
value: '{ALERT.SENDTO}'
|
|
-
|
|
name: trigger_description
|
|
value: '{TRIGGER.DESCRIPTION}'
|
|
-
|
|
name: trigger_id
|
|
value: '{TRIGGER.ID}'
|
|
-
|
|
name: zabbix_url
|
|
value: '{$ZABBIX.URL}'
|
|
attempts: '1'
|
|
script: |
|
|
var SEVERITY_COLORS = [
|
|
'#97AAB3', '#7499FF', '#FFC859',
|
|
'#FFA059', '#E97659', '#E45959'
|
|
];
|
|
|
|
var RESOLVE_COLOR = '#009900';
|
|
|
|
var SEND_MODE_HANDLERS = {
|
|
alarm: handlerAlarm,
|
|
event: handlerEvent
|
|
};
|
|
|
|
if (!String.prototype.format) {
|
|
String.prototype.format = function() {
|
|
var args = arguments;
|
|
|
|
return this.replace(/{(\d+)}/g, function(match, number) {
|
|
return number in args
|
|
? args[number]
|
|
: match
|
|
;
|
|
});
|
|
};
|
|
}
|
|
|
|
function isEventProblem(params) {
|
|
return params.event_value == 1
|
|
&& params.event_update_status == 0
|
|
;
|
|
}
|
|
|
|
function isEventUpdate(params) {
|
|
return params.event_value == 1
|
|
&& params.event_update_status == 1
|
|
;
|
|
}
|
|
|
|
function isEventResolve(params) {
|
|
return params.event_value == 0;
|
|
}
|
|
|
|
function getPermalink(mattermost_url, team_name, postid) {
|
|
return '{0}/{1}/pl/{2}'.format(
|
|
mattermost_url.replace(/\/+$/, ''),
|
|
team_name,
|
|
postid
|
|
);
|
|
}
|
|
|
|
function getChannel(send_to) {
|
|
switch (true) {
|
|
case /.+\/#.+/.test(send_to):
|
|
return getChannelByName(send_to);
|
|
|
|
case /@.+/.test(send_to):
|
|
return getDirectChannel(send_to);
|
|
|
|
default:
|
|
return getChannelByID(send_to);
|
|
}
|
|
}
|
|
|
|
function getChannelByName(send_to) {
|
|
var team_chan = send_to
|
|
.trim()
|
|
.split('/#');
|
|
|
|
var resp = JSON.parse(req.get(
|
|
Mattermost.channel_byname.format(team_chan[0], team_chan[1]),
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
if (req.getStatus() != 200) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
return resp;
|
|
}
|
|
|
|
function getDirectChannel(send_to) {
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Call {0}({1})'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(arguments)
|
|
));
|
|
|
|
var teamUser = send_to
|
|
.trim()
|
|
.split('/@'),
|
|
bot = getBotUser(),
|
|
user = getUserByName(teamUser[1]);
|
|
|
|
var resp = JSON.parse(req.post(
|
|
Mattermost.direct_channel,
|
|
JSON.stringify([bot.id, user.id])
|
|
)
|
|
);
|
|
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Result {0}: {1}'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(resp)
|
|
));
|
|
|
|
if (req.getStatus() != 201) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
resp.team_name = teamUser[0];
|
|
|
|
return resp;
|
|
}
|
|
|
|
function getChannelByID(channelID) {
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Call {0}({1})'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(arguments)
|
|
));
|
|
|
|
var resp = JSON.parse(req.get(
|
|
Mattermost.get_channel.format(channelID),
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Result {0}: {1}'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(resp)
|
|
));
|
|
|
|
if (req.getStatus() != 200) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
return resp;
|
|
}
|
|
|
|
function getBotUser() {
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Call {0}({1})'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(arguments)
|
|
));
|
|
|
|
var resp = JSON.parse(req.get(
|
|
Mattermost.bot_user,
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Result {0}: {1}'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(resp)
|
|
));
|
|
|
|
if (req.getStatus() != 200) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
return resp;
|
|
}
|
|
|
|
function getUserByName(userName) {
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Call {0}({1})'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(arguments)
|
|
));
|
|
|
|
var resp = JSON.parse(req.get(
|
|
Mattermost.user_byname.format(userName),
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Result {0}: {1}'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(resp)
|
|
));
|
|
|
|
if (req.getStatus() != 200) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
return resp;
|
|
}
|
|
|
|
function getTeamByID(teamID) {
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Call {0}({1})'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(arguments)
|
|
));
|
|
|
|
var resp = JSON.parse(req.get(
|
|
Mattermost.get_team.format(teamID),
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
Zabbix.log(5, '[ Mattermost Webhook ] Result {0}: {1}'.format(
|
|
arguments.callee.name,
|
|
JSON.stringify(resp)
|
|
));
|
|
|
|
if (req.getStatus() != 200) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
return resp;
|
|
}
|
|
|
|
function createProblemURL(zabbix_url, triggerid, eventid, event_source) {
|
|
var problem_url = '';
|
|
if (event_source === '0') {
|
|
problem_url = '{0}/tr_events.php?triggerid={1}&eventid={2}'
|
|
.format(
|
|
zabbix_url,
|
|
triggerid,
|
|
eventid
|
|
);
|
|
}
|
|
else {
|
|
problem_url = zabbix_url;
|
|
}
|
|
|
|
return problem_url;
|
|
}
|
|
|
|
function getTagValue(event_tags, key) {
|
|
var pattern = new RegExp('(' + key + ':.+)');
|
|
var tagValue = event_tags
|
|
.split(',')
|
|
.filter(function (v) {
|
|
return v.match(pattern);
|
|
})
|
|
.map(function (v) {
|
|
return v.split(':')[1];
|
|
})[0]
|
|
|| 0;
|
|
|
|
return tagValue;
|
|
}
|
|
|
|
function handlerAlarm(req, params) {
|
|
var channel = getChannel(params.send_to);
|
|
var fields = {
|
|
channel_id: channel.id,
|
|
props: {}
|
|
};
|
|
|
|
if (isEventProblem(params)) {
|
|
var team_name = channel.team_name
|
|
? channel.team_name
|
|
: getTeamByID(channel.team_id).name;
|
|
|
|
fields.props.attachments = [
|
|
createMessage(
|
|
SEVERITY_COLORS[params.event_nseverity] || 0,
|
|
params.event_date,
|
|
params.event_time,
|
|
createProblemURL(params.zabbix_url, params.trigger_id, params.event_id, params.event_source)
|
|
)
|
|
];
|
|
|
|
var resp = JSON.parse(req.post(
|
|
Mattermost.post_message,
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
if (req.getStatus() != 201) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
result.tags.__mattermost_post_id = resp.id;
|
|
result.tags.__mattermost_channel_id = channel.id;
|
|
result.tags.__mattermost_channel_name = channel.name;
|
|
result.tags.__mattermost_message_link = getPermalink(
|
|
params.mattermost_url,
|
|
team_name,
|
|
resp.id
|
|
);
|
|
|
|
}
|
|
else if (isEventUpdate(params)) {
|
|
fields.root_id = getTagValue(params.event_tags, 'mattermost_post_id');
|
|
|
|
if (params.event_source === '0') {}
|
|
fields.props.attachments = [
|
|
createMessage(
|
|
SEVERITY_COLORS[params.event_nseverity] || 0,
|
|
params.event_update_date,
|
|
params.event_update_time,
|
|
createProblemURL(params.zabbix_url, params.trigger_id, params.event_id, params.event_source),
|
|
true
|
|
)
|
|
];
|
|
|
|
resp = JSON.parse(req.post(
|
|
Mattermost.post_message, JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
if (req.getStatus() != 201) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
}
|
|
else if (isEventResolve(params)) {
|
|
fields.channel_id = getTagValue(params.event_tags, 'mattermost_channel_id');
|
|
fields.id = getTagValue(params.event_tags, 'mattermost_post_id');
|
|
fields.props.attachments = [
|
|
createMessage(
|
|
RESOLVE_COLOR,
|
|
params.event_date,
|
|
params.event_time,
|
|
createProblemURL(params.zabbix_url, params.trigger_id, params.event_id, params.event_source)
|
|
)
|
|
];
|
|
|
|
var post_id = getTagValue(params.event_tags, 'mattermost_post_id');
|
|
|
|
resp = JSON.parse(req.put(
|
|
Mattermost.chat_update.format(post_id),
|
|
JSON.stringify(fields)
|
|
)
|
|
);
|
|
|
|
if (req.getStatus() != 200) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
}
|
|
}
|
|
|
|
function handlerEvent(req, params) {
|
|
var channel = getChannel(params.send_to);
|
|
var fields = {
|
|
channel_id: channel.id,
|
|
props: {}
|
|
};
|
|
|
|
if (isEventProblem(params)) {
|
|
var team_name = channel.team_name
|
|
? channel.team_name
|
|
: getTeamByID(channel.team_id).name;
|
|
|
|
fields.props.attachments = [
|
|
createMessage(
|
|
SEVERITY_COLORS[params.event_nseverity] || 0,
|
|
params.event_date,
|
|
params.event_time,
|
|
createProblemURL(params.zabbix_url, params.trigger_id, params.event_id, params.event_source)
|
|
)
|
|
];
|
|
|
|
var resp = JSON.parse(req.post(Mattermost.post_message, JSON.stringify(fields)));
|
|
|
|
if (req.getStatus() != 201) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
result.tags.__mattermost_channel_name = channel.name;
|
|
result.tags.__mattermost_message_link = getPermalink(
|
|
params.mattermost_url,
|
|
team_name,
|
|
resp.id
|
|
);
|
|
|
|
}
|
|
else if (isEventUpdate(params)) {
|
|
fields.props.attachments = [
|
|
createMessage(
|
|
SEVERITY_COLORS[params.event_nseverity] || 0,
|
|
params.event_update_date,
|
|
params.event_update_time,
|
|
createProblemURL(params.zabbix_url, params.trigger_id, params.event_id, params.event_source),
|
|
false
|
|
)
|
|
];
|
|
|
|
resp = JSON.parse(req.post(Mattermost.post_message, JSON.stringify(fields)));
|
|
|
|
if (req.getStatus() != 201) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
|
|
}
|
|
else if (isEventResolve(params)) {
|
|
fields.props.attachments = [
|
|
createMessage(
|
|
RESOLVE_COLOR,
|
|
params.event_recovery_date,
|
|
params.event_recovery_time,
|
|
createProblemURL(params.zabbix_url, params.trigger_id, params.event_id, params.event_source)
|
|
)
|
|
];
|
|
|
|
resp = JSON.parse(req.post(Mattermost.post_message, JSON.stringify(fields)));
|
|
|
|
if (req.getStatus() != 201) {
|
|
throw '[{0}] {1}'.format(resp.status_code, resp.message);
|
|
}
|
|
}
|
|
}
|
|
|
|
function createMessage(
|
|
event_severity_color,
|
|
event_date,
|
|
event_time,
|
|
problem_url,
|
|
isShort
|
|
) {
|
|
var message = {
|
|
fallbac: params.alert_subject,
|
|
title: params.alert_subject,
|
|
color: event_severity_color,
|
|
title_link: problem_url,
|
|
footer: problem_url,
|
|
|
|
fields: [
|
|
{
|
|
title: 'Host',
|
|
value: '{0} [{1}]'.format(params.host_name, params.host_ip),
|
|
short: true
|
|
},
|
|
{
|
|
title: 'Event time',
|
|
value: '{0} {1}'.format(event_date, event_time),
|
|
short: true
|
|
}
|
|
],
|
|
};
|
|
|
|
|
|
if (params.event_source === '0') {
|
|
message.fields.push(
|
|
{
|
|
title: 'Severity',
|
|
value: params.event_severity,
|
|
short: true
|
|
},
|
|
{
|
|
title: 'Opdata',
|
|
value: params.event_opdata,
|
|
short: true
|
|
}
|
|
);
|
|
}
|
|
|
|
if (!isShort && params.event_source === '0') {
|
|
message.fields.push(
|
|
{
|
|
title: 'Event tags',
|
|
value: '`{0}`'.format(params.event_tags.replace(/__.+?:(.+?,|.+)/g, '') || 'None'),
|
|
short: true
|
|
},
|
|
{
|
|
title: 'Trigger description',
|
|
value: params.trigger_description,
|
|
short: true
|
|
}
|
|
);
|
|
}
|
|
|
|
if (params.event_source !== '0' || params.event_update_status === '1') {
|
|
message.fields.push(
|
|
{
|
|
title: 'Details',
|
|
value: params.alert_message,
|
|
short: false
|
|
}
|
|
);
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
function validateParams(params) {
|
|
if (typeof params.bot_token !== 'string' || params.bot_token.trim() === '') {
|
|
throw 'Field "bot_token" cannot be empty';
|
|
}
|
|
|
|
if (isNaN(params.event_id)) {
|
|
throw 'Field "event_id" is not a number';
|
|
}
|
|
|
|
if ([0, 1, 2, 3].indexOf(parseInt(params.event_source)) === -1) {
|
|
throw 'Incorrect "event_source" parameter given: "' + params.event_source + '".\nMust be 0-3.';
|
|
}
|
|
|
|
if (params.event_source !== '0') {
|
|
params.event_nseverity = '0';
|
|
params.event_severity = 'Not classified';
|
|
params.event_update_status = '0';
|
|
params.send_mode = 'event';
|
|
}
|
|
|
|
if (params.event_source === '1' || params.event_source === '2') {
|
|
params.event_value = '1';
|
|
}
|
|
|
|
if (params.event_source === '1') {
|
|
params.host_name = params.discovery_host_dns;
|
|
params.host_ip = params.discovery_host_ip;
|
|
}
|
|
|
|
if ([0, 1, 2, 3, 4, 5].indexOf(parseInt(params.event_nseverity)) === -1) {
|
|
throw 'Incorrect "event_nseverity" parameter given: ' + params.event_nseverity + '\nMust be 0-5.';
|
|
}
|
|
|
|
if (typeof params.event_severity !== 'string' || params.event_severity.trim() === '') {
|
|
throw 'Field "event_severity" cannot be empty';
|
|
}
|
|
|
|
if (params.event_update_status !== '0' && params.event_update_status !== '1') {
|
|
throw 'Incorrect "event_update_status" parameter given: ' + params.event_update_status + '\nMust be 0 or 1.';
|
|
}
|
|
|
|
if (params.event_value !== '0' && params.event_value !== '1') {
|
|
throw 'Incorrect "event_value" parameter given: ' + params.event_value + '\nMust be 0 or 1.';
|
|
}
|
|
|
|
if (typeof params.host_ip !== 'string' || params.host_ip.trim() === '') {
|
|
throw 'Field "host_ip" cannot be empty';
|
|
}
|
|
|
|
if (typeof params.host_name !== 'string' || params.host_name.trim() === '') {
|
|
throw 'Field "host_name" cannot be empty';
|
|
}
|
|
|
|
if (typeof params.mattermost_url !== 'string' || params.mattermost_url.trim() === '') {
|
|
throw 'Field "mattermost_url" cannot be empty';
|
|
}
|
|
|
|
if (!/^(http|https):\/\/.+/.test(params.mattermost_url)) {
|
|
throw 'Field "mattermost_url" must contain a schema';
|
|
}
|
|
|
|
if (['alarm', 'event'].indexOf(params.send_mode) === -1) {
|
|
throw 'Incorrect "send_mode" parameter given: ' + params.send_mode + '\nMust be "alarm" or "event".';
|
|
}
|
|
|
|
if (typeof params.send_to !== 'string' || params.send_to.trim() === '') {
|
|
throw 'Field "send_to" cannot be empty';
|
|
}
|
|
|
|
if (isNaN(params.trigger_id) && params.event_source === '0') {
|
|
throw 'field "trigger_id" is not a number';
|
|
}
|
|
|
|
if (typeof params.zabbix_url !== 'string' || params.zabbix_url.trim() === '') {
|
|
throw 'Field "zabbix_url" cannot be empty';
|
|
}
|
|
|
|
if (!/^(http|https):\/\/.+/.test(params.zabbix_url)) {
|
|
throw 'Field "zabbix_url" must contain a schema';
|
|
}
|
|
|
|
}
|
|
|
|
try {
|
|
var params = JSON.parse(value);
|
|
|
|
validateParams(params);
|
|
|
|
var req = new HttpRequest(),
|
|
fields = {},
|
|
result = {tags: {}};
|
|
|
|
if (typeof params.HTTPProxy === 'string' && params.HTTPProxy.trim() !== '') {
|
|
req.setProxy(params.HTTPProxy);
|
|
}
|
|
|
|
req.addHeader('Content-Type: application/json; charset=utf-8');
|
|
req.addHeader('Authorization: Bearer ' + params.bot_token);
|
|
|
|
params.mattermost_url = params.mattermost_url.replace(/\/+$/, '');
|
|
params.zabbix_url = params.zabbix_url.replace(/\/+$/, '');
|
|
|
|
var APIEndpoint = params.mattermost_url + '/api/v4/';
|
|
|
|
var Mattermost = {
|
|
post_message: APIEndpoint + 'posts',
|
|
get_channel: APIEndpoint + 'channels/{0}',
|
|
get_team: APIEndpoint + 'teams/{0}',
|
|
chat_update: APIEndpoint + 'posts/{0}',
|
|
direct_channel: APIEndpoint + 'channels/direct',
|
|
channel_byname: APIEndpoint + 'teams/name/{0}/channels/name/{1}',
|
|
user_byname: APIEndpoint + 'users/username/{0}',
|
|
bot_user: APIEndpoint + 'users/me'
|
|
|
|
};
|
|
|
|
params.send_mode = params.send_mode.toLowerCase();
|
|
params.send_mode = params.send_mode in SEND_MODE_HANDLERS
|
|
? params.send_mode
|
|
: 'alarm';
|
|
|
|
SEND_MODE_HANDLERS[params.send_mode](req, params);
|
|
|
|
if (params.event_source === '0') {
|
|
return JSON.stringify(result);
|
|
}
|
|
else {
|
|
return 'OK';
|
|
}
|
|
}
|
|
catch (error) {
|
|
Zabbix.log(4, '[ Mattermost Webhook ] Mattermost notification failed: ' + error);
|
|
throw 'Mattermost notification failed: ' + error;
|
|
}
|
|
process_tags: 'YES'
|
|
show_event_menu: 'YES'
|
|
event_menu_url: '{EVENT.TAGS.__mattermost_message_link}'
|
|
event_menu_name: 'Open in Mattermost: {EVENT.TAGS.__mattermost_channel_name}'
|
|
message_templates:
|
|
-
|
|
event_source: TRIGGERS
|
|
operation_mode: PROBLEM
|
|
subject: 'Problem: {EVENT.NAME}'
|
|
message: |
|
|
Problem started at {EVENT.TIME} on {EVENT.DATE}
|
|
Problem name: {EVENT.NAME}
|
|
Host: {HOST.NAME}
|
|
Severity: {EVENT.SEVERITY}
|
|
Operational data: {EVENT.OPDATA}
|
|
Original problem ID: {EVENT.ID}
|
|
{TRIGGER.URL}
|
|
-
|
|
event_source: TRIGGERS
|
|
operation_mode: RECOVERY
|
|
subject: 'Resolved in {EVENT.DURATION}: {EVENT.NAME}'
|
|
message: |
|
|
Problem has been resolved at {EVENT.RECOVERY.TIME} on {EVENT.RECOVERY.DATE}
|
|
Problem name: {EVENT.NAME}
|
|
Problem duration: {EVENT.DURATION}
|
|
Host: {HOST.NAME}
|
|
Severity: {EVENT.SEVERITY}
|
|
Original problem ID: {EVENT.ID}
|
|
{TRIGGER.URL}
|
|
-
|
|
event_source: TRIGGERS
|
|
operation_mode: UPDATE
|
|
subject: 'Updated problem in {EVENT.AGE}: {EVENT.NAME}'
|
|
message: |
|
|
{USER.FULLNAME} {EVENT.UPDATE.ACTION} problem at {EVENT.UPDATE.DATE} {EVENT.UPDATE.TIME}.
|
|
{EVENT.UPDATE.MESSAGE}
|
|
|
|
Current problem status is {EVENT.STATUS}, age is {EVENT.AGE}, acknowledged: {EVENT.ACK.STATUS}.
|
|
-
|
|
event_source: DISCOVERY
|
|
operation_mode: PROBLEM
|
|
subject: 'Discovery: {DISCOVERY.DEVICE.STATUS} {DISCOVERY.DEVICE.IPADDRESS}'
|
|
message: |
|
|
Discovery rule: {DISCOVERY.RULE.NAME}
|
|
|
|
Device IP: {DISCOVERY.DEVICE.IPADDRESS}
|
|
Device DNS: {DISCOVERY.DEVICE.DNS}
|
|
Device status: {DISCOVERY.DEVICE.STATUS}
|
|
Device uptime: {DISCOVERY.DEVICE.UPTIME}
|
|
|
|
Device service name: {DISCOVERY.SERVICE.NAME}
|
|
Device service port: {DISCOVERY.SERVICE.PORT}
|
|
Device service status: {DISCOVERY.SERVICE.STATUS}
|
|
Device service uptime: {DISCOVERY.SERVICE.UPTIME}
|
|
-
|
|
event_source: AUTOREGISTRATION
|
|
operation_mode: PROBLEM
|
|
subject: 'Autoregistration: {HOST.HOST}'
|
|
message: |
|
|
Host name: {HOST.HOST}
|
|
Host IP: {HOST.IP}
|
|
Agent port: {HOST.PORT}
|