salla-gitpuller 1.1.2__tar.gz → 1.2.0__tar.gz

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salla_gitpuller
-Version: 1.1.2
+Version: 1.2.0
 Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
 Author-email: Mohammed Junaid <safijunaid.ss@gmail.com>, Muhammad Zahid <zahidmuhammad127@gmail.com>
 License: MIT
@@ -58,8 +58,9 @@ state to persist across pipeline runs (see [State management](#state-management)
 from gitpuller import GitPullExecutor
 
 executor = GitPullExecutor(
-    slack_webhook_url="https://hooks.slack.com/services/XXX",  # or set CDM_SLACK_WEBHOOK_URL
-    use_mage_ai=True,                                          # persist alert state via Mage
+    use_mage_ai=True,  # persist alert state via Mage
+    # Slack: set CDM_PROD_SLACK_BOT_TOKEN (threaded daily alerts).
+    # Optional: CDM_PROD_DB_SLACK_CHANNEL (defaults to C05MLHR55JT).
 )
 
 result = executor.execute_with_alerting(
@@ -74,7 +75,8 @@ print(result["discarded_changes"])   # what local drift (if any) was wiped
 ```
 
 On failure, `execute_with_alerting` sends a Slack alert (subject to suppression)
-and then **re-raises**, so the Mage pipeline still fails loudly.
+as a **reply in today's daily thread**, then **re-raises**, so the Mage pipeline
+still fails loudly.
 
 ---
 
@@ -116,14 +118,56 @@ and exit code**, which becomes the Slack alert body and the pipeline error.
 
 ## API
 
-### `GitPullExecutor(slack_webhook_url=None, use_mage_ai=False, state_manager=None)`
+### `GitPullExecutor(slack_webhook_url=None, slack_bot_token=None, slack_channel=None, use_mage_ai=False, state_manager=None)`
 
 | Param | Description |
 |-------|-------------|
-| `slack_webhook_url` | Slack incoming-webhook URL. Falls back to the `CDM_SLACK_WEBHOOK_URL` env var. Required (one of the two must be set). |
+| `slack_bot_token` | Slack bot token (`xoxb-...`). Falls back to `CDM_PROD_SLACK_BOT_TOKEN`. Preferred — enables daily-thread replies. |
+| `slack_channel` | Channel ID/name. Falls back to `CDM_PROD_DB_SLACK_CHANNEL`, then `C05MLHR55JT`. |
+| `slack_webhook_url` | Incoming-webhook URL. Falls back to `CDM_SLACK_WEBHOOK_URL`. Used only when no bot token is set (no threading). |
 | `use_mage_ai` | If `True`, persist alert-suppression state via Mage global variables (falls back to in-memory if Mage isn't installed). |
 | `state_manager` | Inject a custom `StateManager`; overrides `use_mage_ai`. |
 
+If neither a bot token nor a webhook is configured, gitpuller still runs and
+prints a warning instead of failing construction.
+
+### Slack daily thread
+
+When `CDM_PROD_SLACK_BOT_TOKEN` is set, failures are posted with `chat.postMessage`:
+
+1. Open (or reuse) one parent message **per workspace per calendar day**:
+   `🚨 Git Pull Failures {workspace_name} — YYYY-MM-DD`.
+2. Post each later failure for that workspace as a **thread reply**.
+
+Daily `thread_ts` values are stored in **one unified Redis hash** shared by every
+Mage workspace (the key is **not** prefixed with `MAGE_WORKSPACE_NAME`):
+
+```text
+gitpuller:slack_thread:{channel}:{YYYY-MM-DD}
+  cloud_data  → JSON { workspace, thread_ts, errors: [{workspace, repo, error, at, reply_ts}, ...] }
+  partner     → JSON { workspace, thread_ts, errors: [...] }
+TTL: until midnight (CDM_SLACK_THREAD_TZ, default UTC)
+```
+
+Each workspace keeps the Slack parent `thread_ts` plus up to 20 git errors
+from that day (error text capped at 1500 chars). Legacy plain `thread_ts`
+strings are still read.
+
+Redis comes from Mage `io_config.yaml` (`REDIS_HOST` / `REDIS_PORT` /
+`REDIS_PASSWORD`), or those same env vars. If Redis is unavailable, gitpuller
+falls back to Slack `conversations.history`.
+
+| Env var | Role |
+|---------|------|
+| `CDM_PROD_SLACK_BOT_TOKEN` | Required for threading. |
+| `CDM_PROD_DB_SLACK_CHANNEL` | Channel; default `C05MLHR55JT`. |
+| `CDM_SLACK_THREAD_TZ` | Timezone for the daily parent date; default `UTC`. |
+| `CDM_PAUSE_SLACK_MESSAGES` | Set to `1` to skip Slack. |
+| `CDM_SLACK_WEBHOOK_URL` | Legacy fallback when no bot token is set. |
+
+The bot must be in the channel (`chat:write`). History reuse also needs
+`channels:history` (or `groups:history` for a private channel).
+
 ### `execute_with_alerting(...)` → `dict`
 
 Runs the sync and, on failure, alerts Slack (with suppression) then re-raises.
@@ -139,6 +183,7 @@ Runs the sync and, on failure, alerts Slack (with suppression) then re-raises.
 | `suppression_hours` | `1` | Don't re-alert on the *same* error within this many hours. |
 | `key_filename` | `None` | Override the on-disk key filename. |
 | `ssh_dir` | `"/home/src/.ssh"` | Directory to write the key into. |
+| `webhook_url` | `None` | Legacy webhook override for this call. Ignored when a bot token is configured. |
 
 ### `execute_git_pull(...)` → `dict`
 
@@ -222,7 +267,21 @@ Keep the version in sync in **both** `pyproject.toml` and `gitpuller/__init__.py
 
 ## Changelog
 
-### 1.1.0 (current)
+### 1.2.0 (current)
+
+- **Threaded Slack alerts.** Failures post as replies under one daily parent
+  **per workspace** (`🚨 Git Pull Failures {workspace} — YYYY-MM-DD`) via
+  `CDM_PROD_SLACK_BOT_TOKEN` and `CDM_PROD_DB_SLACK_CHANNEL`
+  (default `C05MLHR55JT`). Daily `thread_ts` lives in one unified Redis hash
+  (`gitpuller:slack_thread:{channel}:{YYYY-MM-DD}`, field = workspace, TTL
+  until midnight) shared across all Mage workspaces. Each workspace field is
+  JSON: `thread_ts` plus that day's git errors.
+- Incoming webhooks (`CDM_SLACK_WEBHOOK_URL` / `slack_webhook_url`) remain as a
+  non-threaded fallback when no bot token is set.
+- Missing Slack credentials no longer raise on `GitPullExecutor` construction;
+  alerts are skipped with a warning.
+
+### 1.1.0
 
 Reliability and clarity overhaul.
 

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/README.md

@@ -46,8 +46,9 @@ state to persist across pipeline runs (see [State management](#state-management)
 from gitpuller import GitPullExecutor
 
 executor = GitPullExecutor(
-    slack_webhook_url="https://hooks.slack.com/services/XXX",  # or set CDM_SLACK_WEBHOOK_URL
-    use_mage_ai=True,                                          # persist alert state via Mage
+    use_mage_ai=True,  # persist alert state via Mage
+    # Slack: set CDM_PROD_SLACK_BOT_TOKEN (threaded daily alerts).
+    # Optional: CDM_PROD_DB_SLACK_CHANNEL (defaults to C05MLHR55JT).
 )
 
 result = executor.execute_with_alerting(
@@ -62,7 +63,8 @@ print(result["discarded_changes"])   # what local drift (if any) was wiped
 ```
 
 On failure, `execute_with_alerting` sends a Slack alert (subject to suppression)
-and then **re-raises**, so the Mage pipeline still fails loudly.
+as a **reply in today's daily thread**, then **re-raises**, so the Mage pipeline
+still fails loudly.
 
 ---
 
@@ -104,14 +106,56 @@ and exit code**, which becomes the Slack alert body and the pipeline error.
 
 ## API
 
-### `GitPullExecutor(slack_webhook_url=None, use_mage_ai=False, state_manager=None)`
+### `GitPullExecutor(slack_webhook_url=None, slack_bot_token=None, slack_channel=None, use_mage_ai=False, state_manager=None)`
 
 | Param | Description |
 |-------|-------------|
-| `slack_webhook_url` | Slack incoming-webhook URL. Falls back to the `CDM_SLACK_WEBHOOK_URL` env var. Required (one of the two must be set). |
+| `slack_bot_token` | Slack bot token (`xoxb-...`). Falls back to `CDM_PROD_SLACK_BOT_TOKEN`. Preferred — enables daily-thread replies. |
+| `slack_channel` | Channel ID/name. Falls back to `CDM_PROD_DB_SLACK_CHANNEL`, then `C05MLHR55JT`. |
+| `slack_webhook_url` | Incoming-webhook URL. Falls back to `CDM_SLACK_WEBHOOK_URL`. Used only when no bot token is set (no threading). |
 | `use_mage_ai` | If `True`, persist alert-suppression state via Mage global variables (falls back to in-memory if Mage isn't installed). |
 | `state_manager` | Inject a custom `StateManager`; overrides `use_mage_ai`. |
 
+If neither a bot token nor a webhook is configured, gitpuller still runs and
+prints a warning instead of failing construction.
+
+### Slack daily thread
+
+When `CDM_PROD_SLACK_BOT_TOKEN` is set, failures are posted with `chat.postMessage`:
+
+1. Open (or reuse) one parent message **per workspace per calendar day**:
+   `🚨 Git Pull Failures {workspace_name} — YYYY-MM-DD`.
+2. Post each later failure for that workspace as a **thread reply**.
+
+Daily `thread_ts` values are stored in **one unified Redis hash** shared by every
+Mage workspace (the key is **not** prefixed with `MAGE_WORKSPACE_NAME`):
+
+```text
+gitpuller:slack_thread:{channel}:{YYYY-MM-DD}
+  cloud_data  → JSON { workspace, thread_ts, errors: [{workspace, repo, error, at, reply_ts}, ...] }
+  partner     → JSON { workspace, thread_ts, errors: [...] }
+TTL: until midnight (CDM_SLACK_THREAD_TZ, default UTC)
+```
+
+Each workspace keeps the Slack parent `thread_ts` plus up to 20 git errors
+from that day (error text capped at 1500 chars). Legacy plain `thread_ts`
+strings are still read.
+
+Redis comes from Mage `io_config.yaml` (`REDIS_HOST` / `REDIS_PORT` /
+`REDIS_PASSWORD`), or those same env vars. If Redis is unavailable, gitpuller
+falls back to Slack `conversations.history`.
+
+| Env var | Role |
+|---------|------|
+| `CDM_PROD_SLACK_BOT_TOKEN` | Required for threading. |
+| `CDM_PROD_DB_SLACK_CHANNEL` | Channel; default `C05MLHR55JT`. |
+| `CDM_SLACK_THREAD_TZ` | Timezone for the daily parent date; default `UTC`. |
+| `CDM_PAUSE_SLACK_MESSAGES` | Set to `1` to skip Slack. |
+| `CDM_SLACK_WEBHOOK_URL` | Legacy fallback when no bot token is set. |
+
+The bot must be in the channel (`chat:write`). History reuse also needs
+`channels:history` (or `groups:history` for a private channel).
+
 ### `execute_with_alerting(...)` → `dict`
 
 Runs the sync and, on failure, alerts Slack (with suppression) then re-raises.
@@ -127,6 +171,7 @@ Runs the sync and, on failure, alerts Slack (with suppression) then re-raises.
 | `suppression_hours` | `1` | Don't re-alert on the *same* error within this many hours. |
 | `key_filename` | `None` | Override the on-disk key filename. |
 | `ssh_dir` | `"/home/src/.ssh"` | Directory to write the key into. |
+| `webhook_url` | `None` | Legacy webhook override for this call. Ignored when a bot token is configured. |
 
 ### `execute_git_pull(...)` → `dict`
 
@@ -210,7 +255,21 @@ Keep the version in sync in **both** `pyproject.toml` and `gitpuller/__init__.py
 
 ## Changelog
 
-### 1.1.0 (current)
+### 1.2.0 (current)
+
+- **Threaded Slack alerts.** Failures post as replies under one daily parent
+  **per workspace** (`🚨 Git Pull Failures {workspace} — YYYY-MM-DD`) via
+  `CDM_PROD_SLACK_BOT_TOKEN` and `CDM_PROD_DB_SLACK_CHANNEL`
+  (default `C05MLHR55JT`). Daily `thread_ts` lives in one unified Redis hash
+  (`gitpuller:slack_thread:{channel}:{YYYY-MM-DD}`, field = workspace, TTL
+  until midnight) shared across all Mage workspaces. Each workspace field is
+  JSON: `thread_ts` plus that day's git errors.
+- Incoming webhooks (`CDM_SLACK_WEBHOOK_URL` / `slack_webhook_url`) remain as a
+  non-threaded fallback when no bot token is set.
+- Missing Slack credentials no longer raise on `GitPullExecutor` construction;
+  alerts are skipped with a warning.
+
+### 1.1.0
 
 Reliability and clarity overhaul.
 

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/gitpuller/__init__.py

@@ -1,8 +1,3 @@
-"""gitpuller — auto-pull a git repo over SSH inside Mage pipelines.
-
-Public API is re-exported here so callers can ``from gitpuller import ...``.
-"""
-
 from .gitpull import GitPullExecutor
 from .alert_manager import AlertManager
 from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
@@ -10,7 +5,7 @@ from .slack_notifier import SlackNotifier
 from .utils import transform_custom, get_repo_path, get_env_base_path
 
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 __all__ = [
     "GitPullExecutor",
     "AlertManager",

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/gitpuller/alert_manager.py

@@ -1,21 +1,12 @@
-"""Alert de-duplication: decides whether a failure should page Slack."""
-
 from datetime import datetime, timedelta
 from typing import Any, Dict, Optional, Tuple
 from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
 
-
-class AlertManager:
-    """Wraps a ``StateManager`` to suppress repeated identical alerts."""
-
+class AlertManager:    
     def __init__(self, state_manager: Optional[StateManager] = None, use_mage_ai: bool = False):
-        # Pick the backing store for "last alert" bookkeeping:
         if state_manager is not None:
-            # Caller supplied one explicitly.
             self.state_manager = state_manager
         elif use_mage_ai:
-            # Persist across runs via Mage global variables when available,
-            # otherwise degrade gracefully to in-memory (per-process) state.
             try:
                 self.state_manager = MageAIStateManager()
             except ImportError:
@@ -23,43 +14,37 @@ class AlertManager:
                 self.state_manager = InMemoryStateManager()
         else:
             self.state_manager = InMemoryStateManager()
-
+    
     def should_send_alert(
-        self,
-        pipeline_uuid: str,
-        current_error: str,
+        self, 
+        pipeline_uuid: str, 
+        current_error: str, 
         suppression_hours: int = 1
     ) -> Tuple[bool, Dict[str, Any]]:
-        """
-        Decide whether to alert for ``current_error``.
-
-        Rule: alert immediately on a first-ever or *changed* error; for an
-        unchanged error, only re-alert once ``suppression_hours`` has elapsed.
-        Returns ``(should_send, previous_state)``.
-        """
+        
         state = self.state_manager.load_alert_state(pipeline_uuid)
         last_error = state.get("last_error_message")
         last_alert_time_str = state.get("last_alert_time")
-
-        # No prior alert on record — always send.
+        
+        # If no previous alert, always send
         if not last_error or not last_alert_time_str:
             return True, {"last_error_message": None, "last_alert_time": None}
-
-        # A different error than last time — always send.
+        
+        # If error is different, always send
         if last_error != current_error:
             return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
-
-        # Same error as last time — only re-send once the window has elapsed.
+        
+        # Same error - check if enough time has passed
         try:
             last_alert_time = datetime.fromisoformat(last_alert_time_str)
             time_since_last_alert = datetime.now() - last_alert_time
-
+            
             if time_since_last_alert >= timedelta(hours=suppression_hours):
                 return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
             else:
                 return False, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
         except (ValueError, TypeError):
-            # Unparseable timestamp — fail open and alert rather than stay silent.
+            # If we can't parse the time, send the alert to be safe
             return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
     
     def save_alert_state(

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/gitpuller/gitpull.py

@@ -22,11 +22,17 @@ class GitPullExecutor:
     def __init__(
         self,
         slack_webhook_url: Optional[str] = None,
+        slack_bot_token: Optional[str] = None,
+        slack_channel: Optional[str] = None,
         use_mage_ai: bool = False,
         state_manager: Optional[Any] = None
     ):
-        # Slack sink for failure alerts.
-        self.slack_notifier = SlackNotifier(webhook_url=slack_webhook_url)
+        # Slack sink for failure alerts (bot token + daily thread preferred).
+        self.slack_notifier = SlackNotifier(
+            webhook_url=slack_webhook_url,
+            bot_token=slack_bot_token,
+            channel=slack_channel,
+        )
         # Decides whether/when to alert (de-duplicates repeated identical errors).
         self.alert_manager = AlertManager(state_manager=state_manager, use_mage_ai=use_mage_ai)
 
@@ -264,7 +270,12 @@ class GitPullExecutor:
         ``suppression_hours`` caps how often the *same* error is alerted on,
         avoiding Slack spam when a broken state persists across many runs.
         """
-        notifier = SlackNotifier(webhook_url=webhook_url) if webhook_url else self.slack_notifier
+        # webhook_url is a fallback only; CDM_PROD_SLACK_BOT_TOKEN still wins
+        # so Mage callers that pass CDM_SLACK_WEBHOOK_URL stay on the daily thread.
+        if webhook_url and not self.slack_notifier.bot_token:
+            notifier = SlackNotifier(webhook_url=webhook_url)
+        else:
+            notifier = self.slack_notifier
         # Derive a friendly repo name (e.g. "partner-mageai") for the alert.
         repo_name = git_url.split('/')[-1].replace('.git', '')
 
@@ -300,7 +311,11 @@ class GitPullExecutor:
 
             if should_alert:
                 # Post to Slack (cap payload so we don't blow Slack's limits).
-                notifier.send_alert(repo_name, git_output[:1500])
+                notifier.send_alert(
+                    repo_name,
+                    git_output[:1500],
+                    workspace_name=workspace_name,
+                )
 
                 # Record that we alerted so future identical errors are suppressed.
                 self.alert_manager.save_alert_state(

salla_gitpuller-1.2.0/gitpuller/slack_notifier.py

@@ -0,0 +1,579 @@
+import json
+import os
+import time
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+from zoneinfo import ZoneInfo
+
+import requests
+
+SLACK_POST_MESSAGE_URL = "https://slack.com/api/chat.postMessage"
+SLACK_CONVERSATIONS_HISTORY_URL = "https://slack.com/api/conversations.history"
+DEFAULT_SLACK_CHANNEL = "C05MLHR55JT"
+
+# Unified across every Mage deployment — do not prefix with MAGE_WORKSPACE_NAME.
+# One hash per channel per day; field = gitpuller workspace, value = Slack thread_ts.
+REDIS_THREAD_KEY_PREFIX = "gitpuller:slack_thread"
+REDIS_CREATE_LOCK_TTL_SECONDS = 120
+REDIS_ERROR_MAX_CHARS = 1500
+REDIS_ERRORS_PER_WORKSPACE = 20
+
+_redis_client = None
+_redis_init_attempted = False
+
+
+def _get_redis_client():
+    """Mage io_config.yaml first, then REDIS_HOST / REDIS_PORT / REDIS_PASSWORD."""
+    global _redis_client, _redis_init_attempted
+    if _redis_client is not None:
+        return _redis_client
+    if _redis_init_attempted:
+        return None
+    _redis_init_attempted = True
+
+    try:
+        import redis as redis_lib
+    except ImportError:
+        print("⚠️ redis package not installed; Slack thread_ts will not persist across pods")
+        return None
+
+    host = None
+    password = None
+    port = 6379
+    try:
+        from mage_ai.io.config import ConfigFileLoader
+        from mage_ai.settings.repo import get_repo_path
+
+        loader = ConfigFileLoader(os.path.join(get_repo_path(), "io_config.yaml"), "default")
+        host = loader["REDIS_HOST"]
+        password = loader["REDIS_PASSWORD"] or None
+        port = int(loader["REDIS_PORT"])
+    except Exception:
+        host = None
+
+    if not host:
+        host = (os.environ.get("REDIS_HOST") or "").strip() or None
+        password = (os.environ.get("REDIS_PASSWORD") or "").strip() or None
+        port = int(os.environ.get("REDIS_PORT") or 6379)
+
+    if not host:
+        print("⚠️ Redis is not configured; Slack thread_ts will not persist across pods")
+        return None
+
+    try:
+        _redis_client = redis_lib.Redis(
+            host=host,
+            password=password or None,
+            port=port,
+            db=0,
+            decode_responses=True,
+            socket_connect_timeout=5,
+            socket_timeout=5,
+        )
+        _redis_client.ping()
+        return _redis_client
+    except Exception as exc:
+        print(f"⚠️ Redis connection failed: {exc}")
+        _redis_client = None
+        _redis_init_attempted = False
+        return None
+
+
+class SlackNotifier:
+    """Posts formatted failure messages to Slack.
+
+    Bot-token path (preferred): one parent message per workspace per calendar
+    day, each failure as a thread reply. Daily ``thread_ts`` values live in one
+    unified Redis hash (all Mage workspaces share it; TTL until midnight).
+    Webhook path: a standalone channel post.
+    """
+
+    def __init__(
+        self,
+        webhook_url: Optional[str] = None,
+        bot_token: Optional[str] = None,
+        channel: Optional[str] = None,
+    ):
+        self.bot_token = (bot_token or os.environ.get("CDM_PROD_SLACK_BOT_TOKEN") or "").strip() or None
+        self.channel = (
+            (channel or os.environ.get("CDM_PROD_DB_SLACK_CHANNEL") or "").strip()
+            or DEFAULT_SLACK_CHANNEL
+        )
+        self.webhook_url = (webhook_url or os.environ.get("CDM_SLACK_WEBHOOK_URL") or "").strip() or None
+        self._thread_ts_cache: Dict[str, str] = {}
+
+        if not self.bot_token and not self.webhook_url:
+            print(
+                "⚠️ Slack not configured; skipping alerts "
+                "(set CDM_PROD_SLACK_BOT_TOKEN, or CDM_SLACK_WEBHOOK_URL as fallback)"
+            )
+        elif not self.bot_token:
+            print(
+                "⚠️ CDM_PROD_SLACK_BOT_TOKEN is not set; using webhook "
+                "(alerts will not be threaded)"
+            )
+
+    @staticmethod
+    def _is_paused() -> bool:
+        flag = os.environ.get("CDM_PAUSE_SLACK_MESSAGES", "0").lower()
+        return flag in ("1", "true", "yes")
+
+    @staticmethod
+    def _thread_tz() -> str:
+        return os.environ.get("CDM_SLACK_THREAD_TZ", "UTC")
+
+    def _today_date_key(self) -> str:
+        return datetime.now(ZoneInfo(self._thread_tz())).strftime("%Y-%m-%d")
+
+    def _seconds_until_end_of_day(self) -> int:
+        tz = ZoneInfo(self._thread_tz())
+        now = datetime.now(tz)
+        start_next_day = (now + timedelta(days=1)).replace(
+            hour=0, minute=0, second=0, microsecond=0
+        )
+        return max(1, int((start_next_day - now).total_seconds()))
+
+    @staticmethod
+    def _workspace_label(workspace_name: Optional[str] = None) -> str:
+        return (
+            (workspace_name or "").strip()
+            or (os.environ.get("MAGE_WORKSPACE_NAME") or "").strip()
+            or "unknown"
+        )
+
+    def _cache_key(self, date_key: str, workspace: str) -> str:
+        return f"{date_key}:{workspace}"
+
+    def _parent_text(self, date_key: str, workspace: str) -> str:
+        return f"Git Pull Failures {workspace} — daily thread ({date_key})"
+
+    def _parent_header(self, date_key: str, workspace: str) -> str:
+        return f"🚨 Git Pull Failures {workspace} — {date_key}"
+
+    def _redis_daily_key(self, date_key: str) -> str:
+        """One hash for every gitpuller workspace on this channel today."""
+        return f"{REDIS_THREAD_KEY_PREFIX}:{self.channel}:{date_key}"
+
+    def _redis_create_lock_key(self, date_key: str, workspace: str) -> str:
+        return f"{self._redis_daily_key(date_key)}:{workspace}:creating"
+
+    def _remember_thread_ts(self, date_key: str, workspace: str, thread_ts: str) -> None:
+        self._thread_ts_cache[self._cache_key(date_key, workspace)] = thread_ts
+
+    @staticmethod
+    def _parse_workspace_record(raw: Any) -> Dict[str, Any]:
+        """Accept JSON records and the legacy plain thread_ts string."""
+        empty: Dict[str, Any] = {"workspace": None, "thread_ts": None, "errors": []}
+        if raw is None:
+            return empty
+        if isinstance(raw, dict):
+            data = raw
+        else:
+            text = str(raw).strip()
+            if not text:
+                return empty
+            if text.startswith("{"):
+                try:
+                    data = json.loads(text)
+                except json.JSONDecodeError:
+                    return {"workspace": None, "thread_ts": text, "errors": []}
+            else:
+                return {"workspace": None, "thread_ts": text, "errors": []}
+        if not isinstance(data, dict):
+            return empty
+        errors = data.get("errors") or []
+        if not isinstance(errors, list):
+            errors = []
+        thread_ts = data.get("thread_ts")
+        workspace_name = data.get("workspace")
+        return {
+            "workspace": str(workspace_name).strip() if workspace_name else None,
+            "thread_ts": str(thread_ts).strip() if thread_ts else None,
+            "errors": errors,
+        }
+
+    def _load_workspace_record(self, date_key: str, workspace: str) -> Dict[str, Any]:
+        client = _get_redis_client()
+        if not client:
+            return {"workspace": workspace, "thread_ts": None, "errors": []}
+        redis_key = self._redis_daily_key(date_key)
+        try:
+            raw = client.hget(redis_key, workspace)
+        except Exception as exc:
+            print(f"⚠️ Redis HGET failed for {redis_key} field={workspace}: {exc}")
+            return {"workspace": workspace, "thread_ts": None, "errors": []}
+        record = self._parse_workspace_record(raw)
+        record["workspace"] = record.get("workspace") or workspace
+        return record
+
+    def _save_workspace_record(
+        self,
+        date_key: str,
+        workspace: str,
+        record: Dict[str, Any],
+        log_message: Optional[str] = None,
+    ) -> None:
+        client = _get_redis_client()
+        if not client:
+            return
+        redis_key = self._redis_daily_key(date_key)
+        ttl_seconds = self._seconds_until_end_of_day()
+        record = dict(record)
+        record["workspace"] = workspace
+        payload = json.dumps(record, ensure_ascii=False)
+        try:
+            pipe = client.pipeline()
+            pipe.hset(redis_key, workspace, payload)
+            pipe.expire(redis_key, ttl_seconds)
+            pipe.execute()
+            print(
+                log_message
+                or (
+                    f"✅ Saved gitpuller Slack record to Redis "
+                    f"(key={redis_key}, workspace={workspace}, ttl={ttl_seconds}s)"
+                )
+            )
+        except Exception as exc:
+            print(f"⚠️ Redis HSET failed for {redis_key} field={workspace}: {exc}")
+
+    def _read_cached_thread_ts(self, date_key: str, workspace: str) -> Optional[str]:
+        cached = self._thread_ts_cache.get(self._cache_key(date_key, workspace))
+        if cached:
+            return cached
+
+        record = self._load_workspace_record(date_key, workspace)
+        thread_ts = record.get("thread_ts")
+        if thread_ts:
+            self._remember_thread_ts(date_key, workspace, thread_ts)
+            redis_key = self._redis_daily_key(date_key)
+            print(
+                f"ℹ️ Loaded daily Slack thread from Redis "
+                f"(key={redis_key}, workspace={workspace}, ts={thread_ts})"
+            )
+        return thread_ts or None
+
+    def _write_cached_thread_ts(self, date_key: str, workspace: str, thread_ts: str) -> None:
+        self._remember_thread_ts(date_key, workspace, thread_ts)
+        record = self._load_workspace_record(date_key, workspace)
+        record["workspace"] = workspace
+        record["thread_ts"] = thread_ts
+        redis_key = self._redis_daily_key(date_key)
+        ttl_seconds = self._seconds_until_end_of_day()
+        self._save_workspace_record(
+            date_key,
+            workspace,
+            record,
+            log_message=(
+                f"✅ Saved daily Slack thread to Redis "
+                f"(key={redis_key}, workspace={workspace}, ts={thread_ts}, ttl={ttl_seconds}s)"
+            ),
+        )
+
+    def _append_redis_error(
+        self,
+        workspace: str,
+        repo_name: str,
+        error_output: str,
+        thread_ts: Optional[str] = None,
+        reply_ts: Optional[str] = None,
+    ) -> None:
+        if not _get_redis_client():
+            return
+        date_key = self._today_date_key()
+        if thread_ts:
+            self._remember_thread_ts(date_key, workspace, thread_ts)
+        record = self._load_workspace_record(date_key, workspace)
+        record["workspace"] = workspace
+        if thread_ts:
+            record["thread_ts"] = thread_ts
+        error_entry = {
+            "workspace": workspace,
+            "repo": repo_name,
+            "error": (error_output or "")[:REDIS_ERROR_MAX_CHARS],
+            "at": datetime.now(ZoneInfo(self._thread_tz())).strftime("%Y-%m-%d %H:%M:%S %Z"),
+        }
+        if reply_ts:
+            error_entry["reply_ts"] = reply_ts
+        errors = record.get("errors") or []
+        errors.append(error_entry)
+        record["errors"] = errors[-REDIS_ERRORS_PER_WORKSPACE:]
+        redis_key = self._redis_daily_key(date_key)
+        self._save_workspace_record(
+            date_key,
+            workspace,
+            record,
+            log_message=(
+                f"✅ Saved git error to Redis "
+                f"(key={redis_key}, workspace={workspace}, repo={repo_name}, "
+                f"errors={len(record['errors'])})"
+            ),
+        )
+
+    def _acquire_create_lock(self, date_key: str, workspace: str) -> bool:
+        client = _get_redis_client()
+        if not client:
+            return True
+        lock_key = self._redis_create_lock_key(date_key, workspace)
+        try:
+            return bool(
+                client.set(lock_key, "1", nx=True, ex=REDIS_CREATE_LOCK_TTL_SECONDS)
+            )
+        except Exception as exc:
+            print(f"⚠️ Redis SET NX failed for {lock_key}: {exc}")
+            return True
+
+    def _release_create_lock(self, date_key: str, workspace: str) -> None:
+        client = _get_redis_client()
+        if not client:
+            return
+        lock_key = self._redis_create_lock_key(date_key, workspace)
+        try:
+            client.delete(lock_key)
+        except Exception as exc:
+            print(f"⚠️ Redis DELETE failed for {lock_key}: {exc}")
+
+    def _auth_headers(self) -> Dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.bot_token}",
+            "Content-Type": "application/json; charset=utf-8",
+        }
+
+    def _post_bot_message(
+        self,
+        text: str,
+        blocks: Optional[List[Dict[str, Any]]] = None,
+        thread_ts: Optional[str] = None,
+    ) -> Optional[str]:
+        payload: Dict[str, Any] = {
+            "channel": self.channel,
+            "text": text,
+            "mrkdwn": True,
+        }
+        if blocks:
+            payload["blocks"] = blocks
+        if thread_ts:
+            payload["thread_ts"] = thread_ts
+
+        response = requests.post(
+            SLACK_POST_MESSAGE_URL,
+            headers=self._auth_headers(),
+            json=payload,
+            timeout=10,
+        )
+        response.raise_for_status()
+        body = response.json()
+        if not body.get("ok"):
+            raise RuntimeError(body.get("error", "unknown Slack API error"))
+        return body.get("ts")
+
+    def _find_existing_parent_ts(self, date_key: str, workspace: str) -> Optional[str]:
+        """Look in recent channel history for today's gitpuller parent message."""
+        marker = self._parent_text(date_key, workspace)
+        try:
+            response = requests.get(
+                SLACK_CONVERSATIONS_HISTORY_URL,
+                headers=self._auth_headers(),
+                params={"channel": self.channel, "limit": 100},
+                timeout=10,
+            )
+            response.raise_for_status()
+            body = response.json()
+            if not body.get("ok"):
+                print(f"⚠️ Slack history lookup failed: {body.get('error')}")
+                return None
+            for message in body.get("messages") or []:
+                text = message.get("text") or ""
+                ts = message.get("ts")
+                thread_ts = message.get("thread_ts")
+                if marker in text and ts and thread_ts in (None, ts):
+                    return ts
+        except Exception as exc:
+            print(f"⚠️ Slack history lookup failed: {exc}")
+        return None
+
+    def _create_daily_parent(self, date_key: str, workspace: str) -> Optional[str]:
+        parent_text = self._parent_text(date_key, workspace)
+        parent_blocks = [
+            {
+                "type": "header",
+                "text": {
+                    "type": "plain_text",
+                    "text": self._parent_header(date_key, workspace),
+                    "emoji": True,
+                },
+            },
+            {
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": (
+                        f"All gitpuller failure alerts for `{workspace}` today "
+                        "are posted in this thread."
+                    ),
+                },
+            },
+        ]
+        return self._post_bot_message(parent_text, blocks=parent_blocks)
+
+    def _wait_for_redis_thread_ts(
+        self,
+        date_key: str,
+        workspace: str,
+        attempts: int = 10,
+        delay_seconds: float = 0.5,
+    ) -> Optional[str]:
+        if not _get_redis_client():
+            return None
+        for _ in range(attempts):
+            thread_ts = self._read_cached_thread_ts(date_key, workspace)
+            if thread_ts:
+                return thread_ts
+            time.sleep(delay_seconds)
+        return None
+
+    def _get_or_create_daily_thread_ts(self, workspace: str) -> Optional[str]:
+        date_key = self._today_date_key()
+        thread_ts = self._read_cached_thread_ts(date_key, workspace)
+        if thread_ts:
+            return thread_ts
+
+        if not self._acquire_create_lock(date_key, workspace):
+            thread_ts = self._wait_for_redis_thread_ts(date_key, workspace)
+            if thread_ts:
+                print(
+                    f"ℹ️ Loaded daily Slack thread created by another run "
+                    f"(workspace={workspace}, ts={thread_ts})"
+                )
+                return thread_ts
+            print(
+                f"❌ Timed out waiting for daily Slack thread in Redis "
+                f"(workspace={workspace})"
+            )
+            return None
+
+        try:
+            thread_ts = self._read_cached_thread_ts(date_key, workspace)
+            if thread_ts:
+                return thread_ts
+
+            thread_ts = self._find_existing_parent_ts(date_key, workspace)
+            if thread_ts:
+                self._write_cached_thread_ts(date_key, workspace, thread_ts)
+                print(
+                    f"ℹ️ Reused existing daily Slack thread "
+                    f"(workspace={workspace}, ts={thread_ts})"
+                )
+                return thread_ts
+
+            parent_ts = self._create_daily_parent(date_key, workspace)
+            if not parent_ts:
+                print("❌ Slack parent message did not return thread_ts")
+                return None
+
+            self._write_cached_thread_ts(date_key, workspace, parent_ts)
+            return parent_ts
+        finally:
+            self._release_create_lock(date_key, workspace)
+
+    def create_failure_payload(
+        self,
+        repo_name: str,
+        error_output: str,
+        workspace_name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Build the Slack Block Kit payload describing a pull failure."""
+        reported_at = datetime.now(ZoneInfo(self._thread_tz())).strftime(
+            "%Y-%m-%d %H:%M:%S %Z"
+        )
+        workspace = self._workspace_label(workspace_name)
+        details = [
+            f"*Workspace:* `{workspace}`",
+            f"*Repository:* `{repo_name}`",
+            f"*Reported at:* `{reported_at}`",
+        ]
+
+        payload: Dict[str, Any] = {
+            "text": f"Automate Git Pull Pipeline Failed — {workspace} / {repo_name}",
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": ":alert: Automate Git Pull Pipeline Failed :alert:",
+                    },
+                },
+                {"type": "divider"},
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": "\n".join(details),
+                    },
+                },
+            ],
+        }
+
+        if error_output:
+            payload["blocks"].append({
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"*Error Output:*\n```{error_output[:1500]}```",
+                },
+            })
+
+        return payload
+
+    def send_alert(
+        self,
+        repo_name: str,
+        error_output: str = "",
+        workspace_name: Optional[str] = None,
+    ) -> bool:
+        """Send the failure alert. Returns True on success, False on any error
+        (delivery failures are logged but never raised, so alerting can't mask
+        the original git error)."""
+        if self._is_paused():
+            print("ℹ️ Slack notifications paused via CDM_PAUSE_SLACK_MESSAGES")
+            return False
+
+        workspace = self._workspace_label(workspace_name)
+        payload = self.create_failure_payload(repo_name, error_output, workspace)
+        thread_ts: Optional[str] = None
+        reply_ts: Optional[str] = None
+        posted = False
+
+        try:
+            if self.bot_token:
+                thread_ts = self._get_or_create_daily_thread_ts(workspace)
+                if not thread_ts:
+                    print("❌ Could not resolve daily Slack thread_ts")
+                else:
+                    reply_ts = self._post_bot_message(
+                        payload["text"],
+                        blocks=payload["blocks"],
+                        thread_ts=thread_ts,
+                    )
+                    print(
+                        f"✅ Posted Slack alert as thread reply "
+                        f"(thread_ts={thread_ts}, reply_ts={reply_ts})"
+                    )
+                    posted = True
+            elif self.webhook_url:
+                response = requests.post(self.webhook_url, json=payload, timeout=10)
+                response.raise_for_status()
+                print("✅ Alert sent to Slack (webhook, not threaded)")
+                posted = True
+            else:
+                print("⚠️ Slack not configured; skipping alert")
+        except Exception as exc:
+            print(f"⚠️ Failed to send Slack alert: {exc}")
+
+        self._append_redis_error(
+            workspace,
+            repo_name,
+            error_output,
+            thread_ts=thread_ts,
+            reply_ts=reply_ts,
+        )
+        return posted

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/gitpuller/state_manager.py

@@ -1,16 +1,7 @@
-"""Pluggable storage backends for alert-suppression state.
-
-``InMemoryStateManager`` keeps state for the lifetime of the process; the Mage
-variant persists it across pipeline runs via Mage global variables.
-"""
-
 from typing import Any, Dict, Optional
 from datetime import datetime
 
-
-class StateManager:
-    """Abstract interface for persisting per-pipeline alert state."""
-
+class StateManager:    
     def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
         """Load alert state for a pipeline."""
         raise NotImplementedError
@@ -29,11 +20,7 @@ class StateManager:
         """Clear alert state for a pipeline."""
         raise NotImplementedError
 
-class InMemoryStateManager(StateManager):
-    """Process-local state. Note: state is lost when the process exits, so
-    alert suppression only works within a single run unless a persistent
-    backend (e.g. Mage) is used."""
-
+class InMemoryStateManager(StateManager):    
     def __init__(self):
         self._state: Dict[str, Dict[str, Any]] = {}
     
@@ -68,15 +55,11 @@ class InMemoryStateManager(StateManager):
                 "pipeline_status": "success"
             }
 
-class MageAIStateManager(StateManager):
-    """Persists alert state across runs using Mage AI global variables."""
-
+class MageAIStateManager(StateManager):    
     def __init__(self):
-        # Import lazily so the package works outside a Mage environment;
-        # AlertManager catches this ImportError to fall back to in-memory.
         try:
             from mage_ai.data_preparation.variable_manager import (
-                set_global_variable,
+                set_global_variable, 
                 get_global_variable
             )
             self._set_global_variable = set_global_variable

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "salla_gitpuller"
-version = "1.1.2"
+version = "1.2.0"
 description = "A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables"
 readme = "README.md"
 authors = [

{salla_gitpuller-1.1.2 → salla_gitpuller-1.2.0}/salla_gitpuller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salla_gitpuller
-Version: 1.1.2
+Version: 1.2.0
 Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
 Author-email: Mohammed Junaid <safijunaid.ss@gmail.com>, Muhammad Zahid <zahidmuhammad127@gmail.com>
 License: MIT
@@ -58,8 +58,9 @@ state to persist across pipeline runs (see [State management](#state-management)
 from gitpuller import GitPullExecutor
 
 executor = GitPullExecutor(
-    slack_webhook_url="https://hooks.slack.com/services/XXX",  # or set CDM_SLACK_WEBHOOK_URL
-    use_mage_ai=True,                                          # persist alert state via Mage
+    use_mage_ai=True,  # persist alert state via Mage
+    # Slack: set CDM_PROD_SLACK_BOT_TOKEN (threaded daily alerts).
+    # Optional: CDM_PROD_DB_SLACK_CHANNEL (defaults to C05MLHR55JT).
 )
 
 result = executor.execute_with_alerting(
@@ -74,7 +75,8 @@ print(result["discarded_changes"])   # what local drift (if any) was wiped
 ```
 
 On failure, `execute_with_alerting` sends a Slack alert (subject to suppression)
-and then **re-raises**, so the Mage pipeline still fails loudly.
+as a **reply in today's daily thread**, then **re-raises**, so the Mage pipeline
+still fails loudly.
 
 ---
 
@@ -116,14 +118,56 @@ and exit code**, which becomes the Slack alert body and the pipeline error.
 
 ## API
 
-### `GitPullExecutor(slack_webhook_url=None, use_mage_ai=False, state_manager=None)`
+### `GitPullExecutor(slack_webhook_url=None, slack_bot_token=None, slack_channel=None, use_mage_ai=False, state_manager=None)`
 
 | Param | Description |
 |-------|-------------|
-| `slack_webhook_url` | Slack incoming-webhook URL. Falls back to the `CDM_SLACK_WEBHOOK_URL` env var. Required (one of the two must be set). |
+| `slack_bot_token` | Slack bot token (`xoxb-...`). Falls back to `CDM_PROD_SLACK_BOT_TOKEN`. Preferred — enables daily-thread replies. |
+| `slack_channel` | Channel ID/name. Falls back to `CDM_PROD_DB_SLACK_CHANNEL`, then `C05MLHR55JT`. |
+| `slack_webhook_url` | Incoming-webhook URL. Falls back to `CDM_SLACK_WEBHOOK_URL`. Used only when no bot token is set (no threading). |
 | `use_mage_ai` | If `True`, persist alert-suppression state via Mage global variables (falls back to in-memory if Mage isn't installed). |
 | `state_manager` | Inject a custom `StateManager`; overrides `use_mage_ai`. |
 
+If neither a bot token nor a webhook is configured, gitpuller still runs and
+prints a warning instead of failing construction.
+
+### Slack daily thread
+
+When `CDM_PROD_SLACK_BOT_TOKEN` is set, failures are posted with `chat.postMessage`:
+
+1. Open (or reuse) one parent message **per workspace per calendar day**:
+   `🚨 Git Pull Failures {workspace_name} — YYYY-MM-DD`.
+2. Post each later failure for that workspace as a **thread reply**.
+
+Daily `thread_ts` values are stored in **one unified Redis hash** shared by every
+Mage workspace (the key is **not** prefixed with `MAGE_WORKSPACE_NAME`):
+
+```text
+gitpuller:slack_thread:{channel}:{YYYY-MM-DD}
+  cloud_data  → JSON { workspace, thread_ts, errors: [{workspace, repo, error, at, reply_ts}, ...] }
+  partner     → JSON { workspace, thread_ts, errors: [...] }
+TTL: until midnight (CDM_SLACK_THREAD_TZ, default UTC)
+```
+
+Each workspace keeps the Slack parent `thread_ts` plus up to 20 git errors
+from that day (error text capped at 1500 chars). Legacy plain `thread_ts`
+strings are still read.
+
+Redis comes from Mage `io_config.yaml` (`REDIS_HOST` / `REDIS_PORT` /
+`REDIS_PASSWORD`), or those same env vars. If Redis is unavailable, gitpuller
+falls back to Slack `conversations.history`.
+
+| Env var | Role |
+|---------|------|
+| `CDM_PROD_SLACK_BOT_TOKEN` | Required for threading. |
+| `CDM_PROD_DB_SLACK_CHANNEL` | Channel; default `C05MLHR55JT`. |
+| `CDM_SLACK_THREAD_TZ` | Timezone for the daily parent date; default `UTC`. |
+| `CDM_PAUSE_SLACK_MESSAGES` | Set to `1` to skip Slack. |
+| `CDM_SLACK_WEBHOOK_URL` | Legacy fallback when no bot token is set. |
+
+The bot must be in the channel (`chat:write`). History reuse also needs
+`channels:history` (or `groups:history` for a private channel).
+
 ### `execute_with_alerting(...)` → `dict`
 
 Runs the sync and, on failure, alerts Slack (with suppression) then re-raises.
@@ -139,6 +183,7 @@ Runs the sync and, on failure, alerts Slack (with suppression) then re-raises.
 | `suppression_hours` | `1` | Don't re-alert on the *same* error within this many hours. |
 | `key_filename` | `None` | Override the on-disk key filename. |
 | `ssh_dir` | `"/home/src/.ssh"` | Directory to write the key into. |
+| `webhook_url` | `None` | Legacy webhook override for this call. Ignored when a bot token is configured. |
 
 ### `execute_git_pull(...)` → `dict`
 
@@ -222,7 +267,21 @@ Keep the version in sync in **both** `pyproject.toml` and `gitpuller/__init__.py
 
 ## Changelog
 
-### 1.1.0 (current)
+### 1.2.0 (current)
+
+- **Threaded Slack alerts.** Failures post as replies under one daily parent
+  **per workspace** (`🚨 Git Pull Failures {workspace} — YYYY-MM-DD`) via
+  `CDM_PROD_SLACK_BOT_TOKEN` and `CDM_PROD_DB_SLACK_CHANNEL`
+  (default `C05MLHR55JT`). Daily `thread_ts` lives in one unified Redis hash
+  (`gitpuller:slack_thread:{channel}:{YYYY-MM-DD}`, field = workspace, TTL
+  until midnight) shared across all Mage workspaces. Each workspace field is
+  JSON: `thread_ts` plus that day's git errors.
+- Incoming webhooks (`CDM_SLACK_WEBHOOK_URL` / `slack_webhook_url`) remain as a
+  non-threaded fallback when no bot token is set.
+- Missing Slack credentials no longer raise on `GitPullExecutor` construction;
+  alerts are skipped with a warning.
+
+### 1.1.0
 
 Reliability and clarity overhaul.
 

salla_gitpuller-1.1.2/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Mohammed Junaid, Muhammad Zahid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

salla_gitpuller-1.1.2/gitpuller/slack_notifier.py

@@ -1,71 +0,0 @@
-"""Slack incoming-webhook notifier for git-pull failures."""
-
-import os
-import requests
-from typing import Optional, Dict, Any
-
-
-class SlackNotifier:
-    """Posts formatted failure messages to a Slack incoming webhook."""
-
-    def __init__(self, webhook_url: Optional[str] = None):
-        # Explicit arg wins; otherwise fall back to the shared env var.
-        self.webhook_url = webhook_url or os.environ.get("CDM_SLACK_WEBHOOK_URL")
-        if not self.webhook_url:
-            raise ValueError(
-                "Slack webhook URL is required. "
-                "Provide it as parameter or set CDM_SLACK_WEBHOOK_URL environment variable."
-            )
-
-    def create_failure_payload(self, repo_name: str, error_output: str) -> Dict[str, Any]:
-        """Build the Slack Block Kit payload describing a pull failure."""
-        payload = {
-            # "text" is the notification/fallback shown in previews.
-            "text": "Automate Git Pull Pipeline Failed",
-            "blocks": [
-                {
-                    "type": "header",
-                    "text": {
-                        "type": "plain_text",
-                        "text": ":alert: Automate Git Pull Pipeline Failed :alert:"
-                    }
-                },
-                {
-                    "type": "divider"
-                },
-                {
-                    "type": "section",
-                    "text": {
-                        "type": "mrkdwn",
-                        "text": f"*Repository:* `{repo_name}`"
-                    }
-                }
-            ]
-        }
-
-        # Append the captured git error as a code block when present.
-        if error_output:
-            payload["blocks"].append({
-                "type": "section",
-                "text": {
-                    "type": "mrkdwn",
-                    # Cap length so we stay within Slack's 3000-char block limit.
-                    "text": f"*Error Output:*\n```{error_output[:1500]}```"
-                }
-            })
-
-        return payload
-
-    def send_alert(self, repo_name: str, error_output: str = "") -> bool:
-        """Send the failure alert. Returns True on success, False on any error
-        (delivery failures are logged but never raised, so alerting can't mask
-        the original git error)."""
-        try:
-            payload = self.create_failure_payload(repo_name, error_output)
-            response = requests.post(self.webhook_url, json=payload, timeout=10)
-            response.raise_for_status()
-            print("✅ Alert sent to Slack")
-            return True
-        except Exception as e:
-            print(f"⚠️ Failed to send Slack alert: {e}")
-            return False