omdnotificationforwarder 4.1__tar.gz → 4.2__tar.gz

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

@@ -1,3 +1,25 @@
+Metadata-Version: 2.4
+Name: omdnotificationforwarder
+Version: 4.2
+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: nostr
+Requires-Dist: pynostr; 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.
@@ -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.2/README.md

@@ -1,23 +1,3 @@
-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.
@@ -38,6 +18,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 +242,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 +441,3 @@ define command{
                     >> $USER4$/var/log/notificationforwarder_errors.log 2>&1
 }
 ```
-

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

@@ -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.2')
 
     args = parser.parse_args()
     if not hasattr(args, 'formatter'):

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

@@ -21,7 +21,7 @@ packages = ["src/notificationforwarder"]
 
 [project]
 name = "omdnotificationforwarder"
-version = "4.1"
+version = "4.2"
 authors = [
   { name="Gerhard Lausser", email="lausser@yahoo.com" },
 ]
@@ -39,6 +39,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+nostr = [
+    "pynostr",
+]
 test = [
     "requests",
     "flake8",

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

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

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

@@ -0,0 +1,66 @@
+"""Generate a Nostr keypair and derive bech32 values.
+
+```python
+from pynostr.key import PrivateKey
+
+private_key = PrivateKey()
+print(private_key.bech32())          # nsec1...
+print(private_key.public_key.bech32())  # npub1...
+```
+"""
+
+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(["host", host])
+        if service:
+            tags.append(["service", service])
+        if state:
+            tags.append(["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 = {
+            "kind": 4,
+            "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.2/src/notificationforwarder/nostr/forwarder.py

@@ -0,0 +1,141 @@
+import json
+
+from pynostr.encrypted_dm import EncryptedDirectMessage
+from pynostr.event import Event
+from pynostr.key import PrivateKey, PublicKey
+import pynostr.relay as relay_mod
+from pynostr.relay_manager import RelayManager
+
+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)))
+        setattr(self, "kind", int(getattr(self, "kind", 1)))
+
+    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 _private_key(self):
+        if not self.nsec:
+            raise ValueError("nsec is required for Nostr publishing")
+        if hasattr(PrivateKey, "from_nsec"):
+            return PrivateKey.from_nsec(self.nsec)
+        return PrivateKey(self.nsec)
+
+    def _build_event(self, formatted_event):
+        payload = formatted_event.payload or {}
+        if not isinstance(payload, dict):
+            raise ValueError("Nostr formatter must produce a dictionary payload")
+        tags = self._normalize_tags(payload.get("tags", []))
+        extra_tags = []
+        event_forwarder_tags = formatted_event.forwarderopts.get("tags", [])
+        if isinstance(event_forwarder_tags, str):
+            try:
+                event_forwarder_tags = json.loads(event_forwarder_tags)
+            except Exception:
+                event_forwarder_tags = []
+        if isinstance(event_forwarder_tags, (list, tuple)):
+            extra_tags.extend(event_forwarder_tags)
+        forwarder_tags = getattr(self, "tags", [])
+        if isinstance(forwarder_tags, str):
+            try:
+                forwarder_tags = json.loads(forwarder_tags)
+            except Exception:
+                forwarder_tags = []
+        if isinstance(forwarder_tags, (list, tuple)):
+            extra_tags.extend(forwarder_tags)
+        if extra_tags:
+            tags.extend(self._normalize_tags(extra_tags))
+        event = Event(payload.get("content", ""), tags=tags)
+        if hasattr(event, "kind"):
+            event.kind = payload.get("kind", self.kind)
+        return event
+
+    def _recipient_pubkey(self, event):
+        for tag in getattr(event, "tags", []) or []:
+            if isinstance(tag, (list, tuple)) and len(tag) > 1 and tag[0] == "p":
+                return tag[1]
+        raise ValueError("Nostr DM requires a recipient p tag")
+
+    def _normalize_pubkey(self, value):
+        # Accept recipient public keys as either npub1... or raw hex.
+        if not isinstance(value, str):
+            return value
+        value = value.strip()
+        if value.startswith("npub1"):
+            try:
+                return PublicKey.from_npub(value).hex()
+            except Exception:
+                return value
+        return value
+
+    def _normalize_tags(self, tags):
+        normalized = []
+        for tag in tags or []:
+            if isinstance(tag, (list, tuple)) and tag:
+                item = list(tag)
+                if item[0] == "p" and len(item) > 1:
+                    item[1] = self._normalize_pubkey(item[1])
+                normalized.append(item)
+            else:
+                normalized.append(["t", str(tag)])
+        return normalized
+
+    def _close_manager(self, relay_manager):
+        close_methods = [
+            "close_all_relay_connections",
+            "close_connections",
+        ]
+        for method_name in close_methods:
+            method = getattr(relay_manager, method_name, None)
+            if callable(method):
+                method()
+                break
+
+    @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
+        try:
+            private_key = self._private_key()
+            nostr_event = self._build_event(event)
+            recipient_pubkey = self._normalize_pubkey(self._recipient_pubkey(nostr_event))
+            dm = EncryptedDirectMessage()
+            dm.encrypt(
+                private_key.hex(),
+                cleartext_content=nostr_event.content,
+                recipient_pubkey=recipient_pubkey,
+            )
+            nostr_event = dm.to_event()
+            nostr_event.sign(private_key.hex())
+
+            orig_websocket_connect = relay_mod.websocket_connect
+            relay_mod.websocket_connect = lambda *a, **k: orig_websocket_connect(
+                *a, **{**k, "ping_timeout": min(k.get("ping_timeout", 0), k.get("ping_interval", 0))}
+            )
+
+            relay_manager = RelayManager(timeout=self.timeout_seconds)
+            for relay_url in relay_urls:
+                relay_manager.add_relay(relay_url)
+            relay_manager.publish_event(nostr_event)
+            relay_manager.run_sync()
+            self._close_manager(relay_manager)
+            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.2/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)