omdnotificationforwarder 4.1__tar.gz → 4.3__tar.gz

omdnotificationforwarder-4.1/README.md → omdnotificationforwarder-4.3/PKG-INFO

@@ -1,8 +1,30 @@
+Metadata-Version: 2.4
+Name: omdnotificationforwarder
+Version: 4.3
+Summary: A framework for notification scripts for OMD
+Project-URL: Homepage, https://github.com/lausser/noteventificationforhandlerwarder
+Project-URL: Bug Tracker, https://github.com/lausser/noteventificationforhandlerwarder/issues
+Author-email: Gerhard Lausser <lausser@yahoo.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6.1
+Requires-Dist: jinja2
+Provides-Extra: nostr
+Requires-Dist: nostr-sdk; extra == 'nostr'
+Provides-Extra: test
+Requires-Dist: flake8; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: requests; extra == 'test'
+Description-Content-Type: text/markdown
+
 # notificationforwarder
 
 In this framework, two aspects are in the focus. How to transport a notification to the recipient system and in which format.
 In the beginning, Naemon or one of the other monitoring cores will execute a command line. The actual script and the individual command line parameters are defined in a command definition. Typical parameters are (i use the notation of Nagios macros) HOSTNAME, SERVICEDESC, SERVICESTATE, SERVICEOUTPUT. These snippets need to be put together to some kind of payload suitable for the receiving system. And then this payload must be transported to it. We call the two components *formatter* and *forwarder*. The formatter takes the raw input data and creates a payload and the forwarder transmits the payload to the destination.
 What the framework does for you behind the scenes: When forwarding to a recipient fails, the event is saved in a local sqlite database for a certain time and re-sent when the script is called next time and the recipient is available again. Logging of successful and of course failed deliveries is also done automatically.  
+Logging uses the framework's native setup with the standard logfile naming and format used by the built-in tools.
 There is also a component *reporter* which will rarely be used. It's purpose is to run additional code after a successful or failed delivery.  
 
 Let me list some of the formatter/forwarder combinations which are usually found in enterprise environments:
@@ -18,6 +40,8 @@ Let me list some of the formatter/forwarder combinations which are usually found
 |json          |Splunk HEC |
 |json          |RabbitMQ |
 
+|markdown-like Nostr note|Nostr relays |
+
 Of course json is not json, the attributes and values are different depending on the recipient.
 
 
@@ -240,6 +264,34 @@ There is also a SyslogFormatter, which creates the log line as:
 
 If you want a different format, then copy *lib/python/notificationforwarder/syslog/formatter.py* to *local/lib/python/notificationforwarder/syslog/formatter.py* and modify it like you want. Or, with *--formatter*, you can use whatever formatter is suitable, as long as it's payload attribute consists of a line of text.
 
+### Nostr
+
+The Nostr plugin pair publishes an encrypted direct message with labeled lines and default monitoring tags so the alert appears in chat-oriented clients.
+
+Install the optional Nostr support with `pip install notificationforwarder[nostr]`.
+
+|parameter|description|default|
+|---------|-----------|-------|
+|relays|comma-separated relay URLs|`wss://relay.damus.io`|
+|nsec|bech32 private key for signing|required|
+|tags|extra Nostr tags to include|`monitoring` plus host/service/state tags|
+
+Example:
+
+```bash
+$USER1$/notificationforwarder \
+    --forwarder nostr \
+    --forwarderopt relays='wss://relay.damus.io,wss://nostr-pub.wellorder.net' \
+    --forwarderopt nsec='$NSEC$' \
+    --formatter nostr \
+    --eventopt HOSTNAME='$HOSTNAME$' \
+    --eventopt SERVICEDESC='$SERVICEDESC$' \
+    --eventopt SERVICESTATE='$SERVICESTATE$' \
+    --eventopt SERVICEOUTPUT='$SERVICEOUTPUT$'
+```
+
+The recipient `p` tag can be provided through the `tags` forwarder option or custom formatter output. The message content is encrypted before relay publication, so it shows up as a DM in clients that support NIP-04 direct messages.
+
 ## Loggers
 
 The framework uses a modular logging architecture similar to formatters, forwarders, and reporters. By default, notificationforwarder uses **text format logging** - you don't need to do anything, logging works exactly as it did before. The traditional text format is backward compatible with all existing installations.
@@ -411,4 +463,3 @@ define command{
                     >> $USER4$/var/log/notificationforwarder_errors.log 2>&1
 }
 ```
-

omdnotificationforwarder-4.1/PKG-INFO → omdnotificationforwarder-4.3/README.md

@@ -1,28 +1,9 @@
-Metadata-Version: 2.4
-Name: omdnotificationforwarder
-Version: 4.1
-Summary: A framework for notification scripts for OMD
-Project-URL: Homepage, https://github.com/lausser/noteventificationforhandlerwarder
-Project-URL: Bug Tracker, https://github.com/lausser/noteventificationforhandlerwarder/issues
-Author-email: Gerhard Lausser <lausser@yahoo.com>
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.6.1
-Requires-Dist: coshsh
-Requires-Dist: jinja2
-Provides-Extra: test
-Requires-Dist: flake8; extra == 'test'
-Requires-Dist: pytest; extra == 'test'
-Requires-Dist: pytest-cov; extra == 'test'
-Requires-Dist: requests; extra == 'test'
-Description-Content-Type: text/markdown
-
 # notificationforwarder
 
 In this framework, two aspects are in the focus. How to transport a notification to the recipient system and in which format.
 In the beginning, Naemon or one of the other monitoring cores will execute a command line. The actual script and the individual command line parameters are defined in a command definition. Typical parameters are (i use the notation of Nagios macros) HOSTNAME, SERVICEDESC, SERVICESTATE, SERVICEOUTPUT. These snippets need to be put together to some kind of payload suitable for the receiving system. And then this payload must be transported to it. We call the two components *formatter* and *forwarder*. The formatter takes the raw input data and creates a payload and the forwarder transmits the payload to the destination.
 What the framework does for you behind the scenes: When forwarding to a recipient fails, the event is saved in a local sqlite database for a certain time and re-sent when the script is called next time and the recipient is available again. Logging of successful and of course failed deliveries is also done automatically.  
+Logging uses the framework's native setup with the standard logfile naming and format used by the built-in tools.
 There is also a component *reporter* which will rarely be used. It's purpose is to run additional code after a successful or failed delivery.  
 
 Let me list some of the formatter/forwarder combinations which are usually found in enterprise environments:
@@ -38,6 +19,8 @@ Let me list some of the formatter/forwarder combinations which are usually found
 |json          |Splunk HEC |
 |json          |RabbitMQ |
 
+|markdown-like Nostr note|Nostr relays |
+
 Of course json is not json, the attributes and values are different depending on the recipient.
 
 
@@ -260,6 +243,34 @@ There is also a SyslogFormatter, which creates the log line as:
 
 If you want a different format, then copy *lib/python/notificationforwarder/syslog/formatter.py* to *local/lib/python/notificationforwarder/syslog/formatter.py* and modify it like you want. Or, with *--formatter*, you can use whatever formatter is suitable, as long as it's payload attribute consists of a line of text.
 
+### Nostr
+
+The Nostr plugin pair publishes an encrypted direct message with labeled lines and default monitoring tags so the alert appears in chat-oriented clients.
+
+Install the optional Nostr support with `pip install notificationforwarder[nostr]`.
+
+|parameter|description|default|
+|---------|-----------|-------|
+|relays|comma-separated relay URLs|`wss://relay.damus.io`|
+|nsec|bech32 private key for signing|required|
+|tags|extra Nostr tags to include|`monitoring` plus host/service/state tags|
+
+Example:
+
+```bash
+$USER1$/notificationforwarder \
+    --forwarder nostr \
+    --forwarderopt relays='wss://relay.damus.io,wss://nostr-pub.wellorder.net' \
+    --forwarderopt nsec='$NSEC$' \
+    --formatter nostr \
+    --eventopt HOSTNAME='$HOSTNAME$' \
+    --eventopt SERVICEDESC='$SERVICEDESC$' \
+    --eventopt SERVICESTATE='$SERVICESTATE$' \
+    --eventopt SERVICEOUTPUT='$SERVICEOUTPUT$'
+```
+
+The recipient `p` tag can be provided through the `tags` forwarder option or custom formatter output. The message content is encrypted before relay publication, so it shows up as a DM in clients that support NIP-04 direct messages.
+
 ## Loggers
 
 The framework uses a modular logging architecture similar to formatters, forwarders, and reporters. By default, notificationforwarder uses **text format logging** - you don't need to do anything, logging works exactly as it did before. The traditional text format is backward compatible with all existing installations.
@@ -431,4 +442,3 @@ define command{
                     >> $USER4$/var/log/notificationforwarder_errors.log 2>&1
 }
 ```
-

{omdnotificationforwarder-4.1 → omdnotificationforwarder-4.3}/bin/notificationforwarder

@@ -6,7 +6,7 @@ import logging.handlers
 import os
 import sys
 #import logging
-from coshsh.util import setup_logging
+from notificationforwarder.util import setup_logging
 from notificationforwarder import baseclass
 import traceback
 
@@ -78,7 +78,7 @@ Example for an HTTP-based reporter:
                       help='Logger type: text (default) or json, or custom logger module',
                       default='text')
     parser.add_argument('--version', action='version',
-                      version=f'%(prog)s 4.1')
+                      version=f'%(prog)s 4.3')
 
     args = parser.parse_args()
     if not hasattr(args, 'formatter'):

{omdnotificationforwarder-4.1 → omdnotificationforwarder-4.3}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "coshsh"]
+requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build]
@@ -21,7 +21,7 @@ packages = ["src/notificationforwarder"]
 
 [project]
 name = "omdnotificationforwarder"
-version = "4.1"
+version = "4.3"
 authors = [
   { name="Gerhard Lausser", email="lausser@yahoo.com" },
 ]
@@ -34,11 +34,13 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "coshsh",
     "jinja2",
 ]
 
 [project.optional-dependencies]
+nostr = [
+    "nostr-sdk",
+]
 test = [
     "requests",
     "flake8",

{omdnotificationforwarder-4.1 → omdnotificationforwarder-4.3}/src/notificationforwarder/baseclass.py

@@ -11,7 +11,7 @@ except ImportError:
     import json
 
 import logging
-from coshsh.util import setup_logging
+from notificationforwarder.util import setup_logging
 from importlib import import_module
 
 from notificationforwarder.component_loader import (

omdnotificationforwarder-4.3/src/notificationforwarder/nostr/__init__.py

@@ -0,0 +1 @@
+"""Nostr formatter and forwarder for notificationforwarder."""

omdnotificationforwarder-4.3/src/notificationforwarder/nostr/formatter.py

@@ -0,0 +1,54 @@
+import json
+
+from notificationforwarder.baseclass import NotificationFormatter
+
+
+class NostrFormatter(NotificationFormatter):
+    def _pick(self, event, *names, default=""):
+        for name in names:
+            value = event.eventopts.get(name)
+            if value not in (None, ""):
+                return value
+        return default
+
+    def _build_tags(self, host, service, state, extra_tags=None):
+        tags = [["t", "monitoring"]]
+        if host:
+            tags.append(["t", "host=" + host])
+        if service:
+            tags.append(["t", "service=" + service])
+        if state:
+            tags.append(["t", "state=" + state])
+        if isinstance(extra_tags, str):
+            try:
+                extra_tags = json.loads(extra_tags)
+            except Exception:
+                extra_tags = []
+        for tag in extra_tags or []:
+            if isinstance(tag, (list, tuple)) and tag:
+                tags.append(list(tag))
+        return tags
+
+    def format_event(self, event):
+        host = self._pick(event, "HOSTNAME", "HOST", "HOSTNAME_SHORT", "HOSTNAME_FULL")
+        service = self._pick(event, "SERVICEDESC", "SERVICE", default="")
+        state = self._pick(event, "SERVICESTATE", "HOSTSTATE", "STATE", default="")
+        output = self._pick(event, "SERVICEOUTPUT", "HOSTOUTPUT", "OUTPUT", default="")
+
+        lines = [
+            f"Host: {host}",
+            f"Service: {service or '-'}",
+            f"State: {state or '-'}",
+            f"Output: {output or '-'}",
+        ]
+        content = "\n".join(lines)
+        event.payload = {
+            "content": content,
+            "tags": self._build_tags(
+                host,
+                service,
+                state,
+                event.forwarderopts.get("tags"),
+            ),
+        }
+        event.summary = f"{host or 'unknown'}/{service or '-'}: {state or '-'}"

omdnotificationforwarder-4.3/src/notificationforwarder/nostr/forwarder.py

@@ -0,0 +1,130 @@
+import asyncio
+
+try:
+    from nostr_sdk import Client, Keys, NostrSigner, PublicKey, RelayUrl, Tag, uniffi_set_event_loop
+except ImportError as exc:
+    raise ImportError("missing nostr-sdk") from exc
+
+from notificationforwarder.baseclass import NotificationForwarder, timeout
+
+
+class NostrForwarder(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        setattr(self, "relays", getattr(self, "relays", "wss://relay.damus.io"))
+        setattr(self, "relay_urls", getattr(self, "relay_urls", self.relays))
+        setattr(self, "nsec", getattr(self, "nsec", None))
+        setattr(self, "timeout_seconds", int(getattr(self, "timeout_seconds", 6)))
+
+    def _relay_list(self):
+        relays = self.relay_urls if self.relay_urls is not None else self.relays
+        if isinstance(relays, str):
+            return [relay.strip() for relay in relays.split(",") if relay.strip()]
+        if isinstance(relays, (list, tuple)):
+            return [str(relay).strip() for relay in relays if str(relay).strip()]
+        return []
+
+    def _keys(self):
+        if not self.nsec:
+            raise ValueError("nsec is required for Nostr publishing")
+        return Keys.parse(self.nsec)
+
+    def _public_key(self, value):
+        if isinstance(value, PublicKey):
+            return value
+        if not isinstance(value, str):
+            raise ValueError("receiver public key must be a string or PublicKey")
+        return PublicKey.parse(value)
+
+    def _tags(self, formatted_event):
+        tags = []
+        payload = formatted_event.payload or {}
+        tag_values = payload.get("tags", [])
+        if isinstance(tag_values, str):
+            import json
+
+            try:
+                tag_values = json.loads(tag_values)
+            except Exception:
+                tag_values = []
+        if isinstance(tag_values, (list, tuple)):
+            for tag in tag_values:
+                if isinstance(tag, (list, tuple)) and tag:
+                    tags.append(Tag.parse(list(tag)))
+        return tags
+
+    def _configured_tags(self):
+        tag_values = getattr(self, "tags", [])
+        if isinstance(tag_values, str):
+            import json
+
+            try:
+                tag_values = json.loads(tag_values)
+            except Exception:
+                tag_values = []
+        return tag_values if isinstance(tag_values, (list, tuple)) else []
+
+    def _nip_mode(self):
+        return getattr(self, "nip_mode", "nip04")
+
+    async def _send_private_msg(self, relay_urls, receiver_pubkey, message, tags):
+        uniffi_set_event_loop(asyncio.get_running_loop())
+        keys = self._keys()
+        signer = NostrSigner.keys(keys)
+        client = Client(signer)
+        relay_urls = [RelayUrl.parse(url) for url in relay_urls]
+
+        for relay_url in relay_urls:
+            await client.add_relay(relay_url)
+
+        await client.connect()
+        return await client.send_private_msg_to(relay_urls, receiver_pubkey, message, tags)
+
+    async def _send_nip04_dm(self, relay_urls, receiver_pubkey, message):
+        uniffi_set_event_loop(asyncio.get_running_loop())
+        keys = self._keys()
+        signer = NostrSigner.keys(keys)
+        client = Client(signer)
+        relay_urls = [RelayUrl.parse(url) for url in relay_urls]
+
+        for relay_url in relay_urls:
+            await client.add_relay(relay_url)
+
+        await client.connect()
+        return await client.send_private_msg_to(relay_urls, receiver_pubkey, message, [])
+
+    @timeout(30)
+    def submit(self, event):
+        relay_urls = self._relay_list()
+        if not relay_urls:
+            logger.critical("Nostr publish failed: no relays configured")
+            return False
+
+        payload = event.payload or {}
+        nip_mode = self._nip_mode()
+        tags = self._configured_tags() or payload.get("tags", [])
+        recipient_pubkey = None
+        for tag in tags or []:
+            if isinstance(tag, (list, tuple)) and len(tag) > 1 and tag[0] == "p":
+                recipient_pubkey = self._public_key(tag[1])
+                break
+        if recipient_pubkey is None:
+            raise ValueError("Nostr DM requires a recipient p tag")
+
+        try:
+            message = payload.get("content", event.summary or str(payload))
+            nip_mode = self._nip_mode()
+            logger.debug("Nostr NIP mode: {}".format(nip_mode))
+            if nip_mode == "nip17":
+                # For NIP-17, use tags from payload (like [["t", "monitoring"]])
+                tags = self._tags(event)
+                asyncio.run(self._send_private_msg(relay_urls, recipient_pubkey, message, tags))
+            else:
+                # NIP-04: send without tags (nostr-sdk doesn't support NIP-04 tags easily)
+                asyncio.run(self._send_nip04_dm(relay_urls, recipient_pubkey, message))
+            logger.info("published Nostr DM: {}".format(event.summary))
+            self.no_more_logging()
+            return True
+        except Exception as exc:
+            logger.critical("Nostr publish failed: {}".format(str(exc)))
+            return False

omdnotificationforwarder-4.3/src/notificationforwarder/oauth2webhook/forwarder.py

@@ -0,0 +1,98 @@
+import json
+import os
+import time
+import fcntl
+import requests
+requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)
+
+import notificationforwarder.webhook.forwarder as _webhook_module
+from notificationforwarder.webhook.forwarder import WebhookForwarder
+from notificationforwarder.baseclass import NotificationForwarder, timeout
+
+logger = None
+
+
+class Oauth2WebhookForwarder(WebhookForwarder):
+    def __init__(self, opts):
+        # Call NotificationForwarder directly to avoid infinite recursion from
+        # WebhookForwarder's super(self.__class__, self) pattern when subclassed.
+        NotificationForwarder.__init__(self, opts)
+        # Webhook attribute defaults
+        setattr(self, "url", getattr(self, "url", "http://localhost:12345"))
+        setattr(self, "username", getattr(self, "username", None))
+        setattr(self, "password", getattr(self, "password", None))
+        setattr(self, "insecure", getattr(self, "insecure", "yes"))
+        setattr(self, "headers", getattr(self, "headers", None))
+        # OAuth2 attribute defaults
+        setattr(self, "token_url", getattr(self, "token_url", None))
+        setattr(self, "client_id", getattr(self, "client_id", None))
+        setattr(self, "client_secret", getattr(self, "client_secret", None))
+        setattr(self, "token_scope", getattr(self, "token_scope", None))
+        setattr(self, "token_grant_type", getattr(self, "token_grant_type", "client_credentials"))
+        setattr(self, "token_expiry_buffer", int(getattr(self, "token_expiry_buffer", 30)))
+
+    def _token_cache_path(self):
+        return os.path.join(
+            os.environ["OMD_ROOT"], "var", "tmp",
+            "notificationforwarder_{}_oauth2token.json".format(self.forwarder_name),
+        )
+
+    def acquire_token(self):
+        cache_path = self._token_cache_path()
+        lock_path = cache_path + ".lock"
+
+        with open(lock_path, "w") as lf:
+            fcntl.flock(lf, fcntl.LOCK_EX)
+            try:
+                if os.path.exists(cache_path):
+                    with open(cache_path) as f:
+                        cached = json.load(f)
+                    if time.time() < cached.get("expires_at", 0) - self.token_expiry_buffer:
+                        logger.debug("oauth2: using cached token")
+                        return cached["access_token"]
+
+                logger.debug("oauth2: acquiring new token from {}".format(self.token_url))
+                data = {
+                    "grant_type": self.token_grant_type,
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                }
+                if self.token_scope:
+                    data["scope"] = self.token_scope
+
+                resp = requests.post(
+                    self.token_url,
+                    data=data,
+                    timeout=10,
+                    verify=(self.insecure != "yes"),
+                )
+                resp.raise_for_status()
+                token_data = resp.json()
+                token = token_data["access_token"]
+                expires_in = int(token_data.get("expires_in", 3600))
+                expires_at = time.time() + expires_in
+
+                with open(cache_path, "w") as f:
+                    json.dump({"access_token": token, "expires_at": expires_at}, f)
+
+                logger.debug("oauth2: token acquired, valid for {}s".format(expires_in))
+                return token
+            except Exception as e:
+                logger.critical("oauth2: token acquisition failed: {}".format(e))
+                raise
+            finally:
+                fcntl.flock(lf, fcntl.LOCK_UN)
+
+    def submit_one(self, event):
+        # Sync logger into the webhook module so WebhookForwarder.submit_one can use it.
+        _webhook_module.logger = logger
+        try:
+            token = self.acquire_token()
+        except Exception:
+            return False
+        hdrs = event.forwarderopts.get("headers") or {}
+        if isinstance(hdrs, str):
+            hdrs = json.loads(hdrs)
+        hdrs["Authorization"] = "Bearer {}".format(token)
+        event.forwarderopts["headers"] = hdrs
+        return super().submit_one(event)

omdnotificationforwarder-4.3/src/notificationforwarder/util.py

@@ -0,0 +1,37 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+import sys
+
+
+def setup_logging(logdir=".", logfile="notificationforwarder.log", scrnloglevel=logging.INFO, txtloglevel=logging.INFO, format="%(asctime)s %(process)d - %(levelname)s - %(message)s", backup_count=3):
+    logdir_path = Path(logdir)
+    logdir_path.mkdir(parents=True, exist_ok=True)
+
+    logfile_path = Path(logfile)
+    abs_logfile = logfile_path if logfile_path.is_absolute() else logdir_path / logfile_path
+    abs_logfile.touch(exist_ok=True)
+    logger_name = abs_logfile.name[:-4] if abs_logfile.name.endswith(".log") else abs_logfile.name
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+
+    for handler in list(logger.handlers):
+        handler.close()
+        logger.removeHandler(handler)
+
+    formatter = logging.Formatter(format)
+
+    file_handler = RotatingFileHandler(str(abs_logfile), maxBytes=20 * 1024 * 1024, backupCount=backup_count, delay=True)
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(txtloglevel)
+    logger.addHandler(file_handler)
+
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(scrnloglevel)
+    logger.addHandler(console_handler)
+
+    logger.debug("Logger initialized.")
+
+    return logger

{omdnotificationforwarder-4.1 → omdnotificationforwarder-4.3}/tests/test_alertmanager.py

@@ -149,7 +149,7 @@ def test_alertmanager_forwarder(setup):
     }
 
 
-    amgw = notificationforwarder.baseclass.new("webhook", None, "alertmanager_servicenow", False, False,  forwarderopts)
+    amgw = notificationforwarder.baseclass.new("webhook", None, "alertmanager_servicenow", True, True,  forwarderopts)
     famgw = amgw.new_formatter()
     assert famgw.__class__.__name__ == "AlertmanagerServicenowFormatter"
     assert famgw.__module_file__.endswith("pythonpath/local/lib/python/notificationforwarder/alertmanager_servicenow/formatter.py")
@@ -158,9 +158,10 @@ def test_alertmanager_forwarder(setup):
 
     amgw.forward(eventopts)
     log = open(get_logfile(amgw)).read()
+    assert "event has no node" in log
+    assert "replace node with 4490.example.net" in log
     assert re.search(r'success: alertmanager sends 2 alarms.*result is .*"records": 2.*4490.*4491.*', log, flags=re.MULTILINE)
 
     http_server.shutdown()
 
 
-