maubot-alertbot/alertbot.py
2022-08-24 19:41:01 +02:00

141 lines
4.4 KiB
Python

from maubot import Plugin, MessageEvent
from maubot.handlers import web, command
from aiohttp.web import Request, Response, json_response
import json
import datetime
helpstring = f"""# Alertbot
To control the alertbot you can use the following commands:
* `!help`: To show this help
* `!ping`: To check if the bot is alive
* `!raw`: To toggle raw mode (where webhook data is not parsed but simply forwarded as copyable text)
* `!roomid`: To let the bot show you the current matrix room id
* `!url`: To let the bot show you the webhook url
More information is on [Github](https://github.com/moan0s/alertbot)
"""
def get_alert_messages(alertmanager_data: dict, raw_mode=False) -> list:
"""
Returns a list of messages in markdown format
:param raw_mode: Toggles a mode where the data is not parsed but simply returned as code block in a message
:param alertmanager_data:
:return: List of alert messages in markdown format
"""
if raw_mode:
return ["**Data received**\n```\n" + str(alertmanager_data).strip("\n").strip() + "\n```"]
messages = []
""" try:
# Check if grafana alert/resolved
if alertmanager_data['alerts']:
messages.append(grafana_alert_to_markdown(alertmanager_data))
except KeyError:
"""
for alert in alertmanager_data["alerts"]:
messages.append(alert_to_markdown(alert))
return messages
def alert_to_markdown(alert: dict) -> str:
if alert["fingerprint"]:
return grafana_alert_to_markdown(alert)
else:
return prometheus_alert_to_markdown(alert)
def grafana_alert_to_markdown(alert: dict) -> str:
"""
Converts a grafana alert json to markdown
:param alert:
:return: Alert as fomatted markdown
"""
datetime_format = "%Y-%m-%dT%H:%M:%S%z"
if alert['status'] == "firing":
message = (
f"""**Firing 🔥**: {alert['labels']['alertname']}
* **Instance:** {alert["valueString"]}
* **Silence:** {alert["silenceURL"]}
* **Started at:** {alert['startsAt']}
* **Fingerprint:** {alert['fingerprint']}
"""
)
if alert['status'] == "resolved":
end_at = datetime.datetime.strptime(alert['endsAt'], datetime_format)
start_at = datetime.datetime.strptime(alert['startsAt'], datetime_format)
message = (
f"""**Resolved 🥳**: {alert['labels']['alertname']}
* **Duration until resolved:** {end_at - start_at}
* **Fingerprint:** {alert['fingerprint']}
"""
)
return message
def prometheus_alert_to_markdown(alert: dict) -> str:
"""
Converts a prometheus alert json to markdown
:param alert:
:return: Alert as fomatted markdown
"""
message = (
f"""**{alert['status']}**: {alert['annotations']['description']}
* **Alertname:** {alert["labels"]['alertname']}
* **Instance:** {alert["labels"]['instance']}
* **Job:** {alert["labels"]['job']}
"""
)
return message
class AlertBot(Plugin):
raw_mode = False
async def send_alert(self, req, room):
text = await req.text()
self.log.info(text)
content = json.loads(f"{text}")
for message in get_alert_messages(content, self.raw_mode):
self.log.debug(f"Sending alert to {room}")
await self.client.send_markdown(room, message)
@web.post("/webhook/{room_id}")
async def webhook_room(self, req: Request) -> Response:
room_id = req.match_info["room_id"].strip()
await self.send_alert(req, room=room_id)
return json_response({"status": "ok"})
@command.new()
async def ping(self, evt: MessageEvent) -> None:
"""Answers pong to check if the bot is running"""
await evt.reply("pong")
@command.new()
async def roomid(self, evt: MessageEvent) -> None:
"""Answers with the current room id"""
await evt.reply(f"`{evt.room_id}`")
@command.new()
async def url(self, evt: MessageEvent) -> None:
"""Answers with the url of the webhook"""
await evt.reply(f"`{self.webapp_url}/webhook`")
@command.new()
async def raw(self, evt: MessageEvent) -> None:
self.raw_mode = not self.raw_mode
"""Switches the bot to raw mode or disables raw mode (mode where data is not formatted but simply forwarded)"""
await evt.reply(f"Mode is now: `{'raw' if self.raw_mode else 'normal'} mode`")
@command.new()
async def help(self, evt: MessageEvent) -> None:
await self.client.send_markdown(evt.room_id, helpstring)