omdnotificationforwarder 4.2__tar.gz → 4.4__tar.gz

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdnotificationforwarder
-Version: 4.2
+Version: 4.4
 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
@@ -9,10 +9,9 @@ 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'
+Requires-Dist: nostr-sdk; extra == 'nostr'
 Provides-Extra: test
 Requires-Dist: flake8; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
@@ -25,6 +24,7 @@ Description-Content-Type: text/markdown
 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:

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/README.md

@@ -3,6 +3,7 @@
 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:

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/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.2')
+                      version=f'%(prog)s 4.4')
 
     args = parser.parse_args()
     if not hasattr(args, 'formatter'):

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/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.2"
+version = "4.4"
 authors = [
   { name="Gerhard Lausser", email="lausser@yahoo.com" },
 ]
@@ -34,13 +34,12 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "coshsh",
     "jinja2",
 ]
 
 [project.optional-dependencies]
 nostr = [
-    "pynostr",
+    "nostr-sdk",
 ]
 test = [
     "requests",

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/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 (
@@ -415,6 +415,7 @@ class NotificationForwarder(object):
         with open(self.db_lock_file, "w") as lock_file:
             locked = self.acquire_lock_with_retry(lock_file)
             if locked:
+                self.baseclass_logs_summary = True
                 try:
                     dropped = self.spool_store.prune_expired(self.max_spool_minutes)
                     replay_attempted = 0
@@ -449,7 +450,14 @@ class NotificationForwarder(object):
                             for id, text in id_events:
                                 raw_event = self.spool_store.decode(text)
                                 formatted_event = self.format_event(raw_event)
-                                if formatted_event:
+                                if formatted_event and formatted_event.is_discarded:
+                                    deleted_trash += 1
+                                    logger.info("discard spooled event during replay", {
+                                        'event_id': id,
+                                        'action': 'discard_during_replay'
+                                    })
+                                    self.spool_store.delete(id)
+                                elif formatted_event:
                                     replay_attempted += 1
                                     try:
                                         result = self.submit(formatted_event)

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/src/notificationforwarder/email/forwarder.py

@@ -5,6 +5,8 @@ from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
 from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
 
+logger = logging.getLogger("notificationforwarder.email")
+
 class EmailForwarder(NotificationForwarder):
     def __init__(self, opts):
         super(self.__class__, self).__init__(opts)
@@ -31,6 +33,6 @@ class EmailForwarder(NotificationForwarder):
             server.quit()
             return True
         except Exception as e:
-            logging.critical("sending mail failed: {}".format(str(e)))
+            logger.critical("sending mail failed: {}".format(str(e)))
             return False
 

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/src/notificationforwarder/nostr/formatter.py

@@ -1,14 +1,3 @@
-"""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
@@ -25,11 +14,11 @@ class NostrFormatter(NotificationFormatter):
     def _build_tags(self, host, service, state, extra_tags=None):
         tags = [["t", "monitoring"]]
         if host:
-            tags.append(["host", host])
+            tags.append(["t", "host=" + host])
         if service:
-            tags.append(["service", service])
+            tags.append(["t", "service=" + service])
         if state:
-            tags.append(["state", state])
+            tags.append(["t", "state=" + state])
         if isinstance(extra_tags, str):
             try:
                 extra_tags = json.loads(extra_tags)
@@ -54,7 +43,6 @@ class NostrFormatter(NotificationFormatter):
         ]
         content = "\n".join(lines)
         event.payload = {
-            "kind": 4,
             "content": content,
             "tags": self._build_tags(
                 host,

omdnotificationforwarder-4.4/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.2 → omdnotificationforwarder-4.4}/src/notificationforwarder/spool.py

@@ -4,6 +4,7 @@ except ImportError:
     import json
 import random
 import sqlite3
+import threading
 import time
 import fcntl
 
@@ -14,6 +15,7 @@ class SpoolStore:
         self.table_name = table_name
         self.connection = None
         self.cursor = None
+        self._lock = threading.Lock()
 
     def open(self):
         self.connection = sqlite3.connect(self.db_file, check_same_thread=False)
@@ -25,45 +27,53 @@ class SpoolStore:
                 payload TEXT NOT NULL,
                 timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
             )"""
-        self.cursor.execute(sql_create)
-        self.connection.commit()
+        with self._lock:
+            self.cursor.execute(sql_create)
+            self.connection.commit()
 
     def count(self):
-        self.cursor.execute("SELECT COUNT(*) FROM " + self.table_name)
-        return self.cursor.fetchone()[0]
+        with self._lock:
+            self.cursor.execute("SELECT COUNT(*) FROM " + self.table_name)
+            return self.cursor.fetchone()[0]
 
     def enqueue(self, raw_event):
         sql_insert = "INSERT INTO " + self.table_name + "(payload) VALUES (?)"
-        self.cursor.execute(sql_insert, (json.dumps(raw_event),))
-        self.connection.commit()
+        with self._lock:
+            self.cursor.execute(sql_insert, (json.dumps(raw_event),))
+            self.connection.commit()
 
     def prune_expired(self, max_spool_minutes):
         outdated = int(time.time() - 60 * max_spool_minutes)
         sql_delete = "DELETE FROM " + self.table_name + " WHERE CAST(STRFTIME('%s', timestamp) AS INTEGER) < ?"
-        self.cursor.execute(sql_delete, (outdated,))
-        return self.cursor.rowcount
+        with self._lock:
+            self.cursor.execute(sql_delete, (outdated,))
+            return self.cursor.rowcount
 
     def fetch_batch(self, limit=10):
         sql_select = "SELECT id, payload FROM " + self.table_name + " ORDER BY id LIMIT ?"
-        self.cursor.execute(sql_select, (limit,))
-        return self.cursor.fetchall()
+        with self._lock:
+            self.cursor.execute(sql_select, (limit,))
+            return self.cursor.fetchall()
 
     def delete(self, event_id):
-        self.cursor.execute("DELETE FROM " + self.table_name + " WHERE id = ?", (event_id,))
-        self.connection.commit()
+        with self._lock:
+            self.cursor.execute("DELETE FROM " + self.table_name + " WHERE id = ?", (event_id,))
+            self.connection.commit()
 
     def decode(self, text):
         return json.loads(text)
 
     def commit(self):
-        self.connection.commit()
+        with self._lock:
+            self.connection.commit()
 
     def close(self):
-        if self.cursor:
-            self.cursor.close()
-        if self.connection:
-            self.connection.commit()
-            self.connection.close()
+        with self._lock:
+            if self.cursor:
+                self.cursor.close()
+            if self.connection:
+                self.connection.commit()
+                self.connection.close()
 
 
 def acquire_lock_with_retry(lock_file, app_logger, max_attempts=3, base_delay=0.1):

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/src/notificationforwarder/syslog/forwarder.py

@@ -3,6 +3,8 @@ import socket
 import logging
 from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
 
+logger = logging.getLogger("notificationforwarder.syslog")
+
 
 class SyslogForwarder(NotificationForwarder):
     def __init__(self, opts):

{omdnotificationforwarder-4.2 → omdnotificationforwarder-4.4}/src/notificationforwarder/telegram/forwarder.py

@@ -1,12 +1,15 @@
+import logging
 import requests
 import urllib.parse
 from notificationforwarder.baseclass import NotificationForwarder, timeout
 
+logger = logging.getLogger("notificationforwarder.telegram")
+
 class TelegramForwarder(NotificationForwarder):
     def __init__(self, opts):
         super(self.__class__, self).__init__(opts)
         setattr(self, "bot_token", getattr(self, "bot_token", None))
-        setattr(self, "chat_id", getattr(self, "hat_id", None))
+        setattr(self, "chat_id", getattr(self, "chat_id", None))
 
     @timeout(30)
     def submit(self, event):
@@ -33,7 +36,7 @@ class TelegramForwarder(NotificationForwarder):
             request_params["text"] = urllib.parse.quote(event.payload)
             request_params["parse_mode"] = "MarkdownV2"
             request_params["chat_id"] = self.chat_id
-            response = requests.get("https://api.telegram.org/bot{}/sendMessage".format(self.bot_token), params=request_parms)
+            response = requests.get("https://api.telegram.org/bot{}/sendMessage".format(self.bot_token), params=request_params)
             if response.status_code == requests.codes.ok:
                 logger.info("success: {} result is {}, request was {}".format(event.summary, response.text, request_params))
                 return True

omdnotificationforwarder-4.4/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