【AI技术_工具_资讯】用 Python 写一个「自愈式」定时任务：失败自动重试 + 飞书告警

前言

做过运维或自动化的人都有过这样的经历：写好了一个定时爬虫，凌晨两点它静悄悄地挂了，报错日志淹没在系统消息里。你一觉醒来发现当天数据全空了，只能手忙脚乱地手动补跑。

问题不在「写脚本」，而在「让脚本可靠运行」。今天我们来实战做一个自愈式定时任务框架------它会：

• 在固定时间自动执行你的任务

• 失败后按指数退避策略自动重试（1min → 2min → 4min...）

• 重试仍失败时，自动推送告警到飞书/钉钉

• 全程记录日志，失败恢复后可断点续跑

  

不需要 systemd、不需要 cron 表达式满天飞，纯 Python 3.8+ 即可跑起来，30 行核心代码就能搞定一个生产级的守护任务。

主题介绍

传统定时任务（crontab / Windows 计划任务）只管「按时触发」，不管「是否成功」。一旦网络抖动、API 限流、依赖服务短暂不可用，任务就白跑了，没有任何补救。

自愈式定时任务的核心思想是：把「执行」和「可靠性」解耦：

1. 调度层：负责「什么时候触发」

2. 执行层：负责「跑什么」

3. 自愈层：负责「失败了怎么办」

4. 告警层 ：负责「彻底失败了通知谁」

   

我们今天就实现一个最小可运行的自愈框架，再配上飞书告警和断点续跑，凑成一个可以直接投入生产的模板。

环境准备

Python 版本要求 ：3.8+（用到了 dataclasses 和 asyncio）

需要安装的库：

pip install requests schedule apscheduler

schedule 适合简单定时，APScheduler 适合复杂调度。本文为保持代码精简，使用 schedule，几行就能完成定时。

飞书/钉钉 Webhook（可选）：登录飞书开放平台，在群机器人中创建自定义机器人，复制 Webhook 地址。格式类似：

https://open.feishu.cn/open-apis/bot/v2/hook/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

本地测试时可以用一个空的 Webhook 占位，告警功能会优雅降级。

实操步骤

步骤 1：定义任务与执行单元

每个任务是一个可调用的函数，框架会自动注入重试逻辑。我们先定义任务结构：

from dataclasses import dataclass, field
from datetime import datetime
from typing import Callable, Any
import logging

logger = logging.getLogger(__name__)

@dataclass
class TaskSpec:
    """任务规格：名字、执行函数、重试次数、退避倍率"""
    name: str
    func: Callable[[], Any]
    max_retries: int = 3
    backoff_base_seconds: float = 60.0  # 1min, 2min, 4min...
    last_success: datetime | None = None
    last_run: datetime | None = None

    def run(self) -> bool:
        """执行任务，返回 True 表示成功"""
        import traceback
        try:
            self.func()
            self.last_success = self.last_run = datetime.now()
            logger.info(f"[{self.name}] 任务执行成功")
            return True
        except Exception as e:
            logger.warning(f"[{self.name}] 任务失败: {e}")
            traceback.print_exc()
            return False

步骤 2：实现自愈重试逻辑

失败后不立即重跑，而是按指数退避等待，避免在对方服务还没恢复时反复冲击：

import time

def run_with_retry(task: TaskSpec) -> bool:
    """带指数退避重试的执行器"""
    for attempt in range(1, task.max_retries + 1):
        if task.run():
            return True
        if attempt < task.max_retries:
            wait = task.backoff_base_seconds * (2 ** (attempt - 1))
            logger.info(
                f"[{task.name}] 第 {attempt} 次失败，"
                f"{wait:.0f}s 后第 {attempt + 1} 次重试..."
            )
            time.sleep(wait)
    return False

退避序列示例（base=60s, retries=3）：

尝试次数	等待时长	累计耗时
第 1 次	立即执行	0s
第 2 次	60s	~60s
第 3 次	120s	~180s

这给了下游服务充足的恢复窗口，同时不会无限重试导致资源耗尽。

步骤 3：添加飞书/钉钉告警

告警是最后的安全网，只在所有重试都失败时触发：

import requests

def send_feishu_alert(webhook_url: str, task: TaskSpec) -> None:
    """发送飞书告警（优雅降级：URL 无效时不报错）"""
    if not webhook_url:
        logger.warning("飞书 Webhook 未配置，跳过告警")
        return
    payload = {
        "msg_type": "text",
        "content": {
            "text": (
                f"🚨 定时任务失败告警\n"
                f"任务名称: {task.name}\n"
                f"失败时间: {task.last_run.isoformat()}\n"
                f"重试次数: {task.max_retries}（全部失败）\n"
                f"请检查日志并手动触发恢复"
            )
        }
    }
    try:
        resp = requests.post(webhook_url, json=payload, timeout=5)
        if resp.status_code == 200:
            logger.info(f"[{task.name}] 飞书告警已发送")
        else:
            logger.error(f"[{task.name}] 告警发送失败: HTTP {resp.status_code}")
    except Exception as e:
        logger.error(f"[{task.name}] 告警发送异常: {e}")


def send_dingtalk_alert(webhook_url: str, task: TaskSpec) -> None:
    """发送钉钉告警（兼容钉钉机器人）"""
    if not webhook_url:
        return
    payload = {
        "msgtype": "text",
        "text": {
            "content": (
                f"🚨 定时任务失败告警\n"
                f"任务: {task.name}\n"
                f"时间: {task.last_run.isoformat()}\n"
                f"重试 {task.max_retries} 次后仍失败，请及时处理"
            )
        }
    }
    try:
        resp = requests.post(webhook_url, json=payload, timeout=5)
        if resp.status_code == 200:
            logger.info(f"[task={task.name}] 钉钉告警已发送")
    except Exception as e:
        logger.error(f"[task={task.name}] 钉钉告警失败: {e}")

步骤 4：组装定时调度器

用 schedule 库把任务挂到时间表上，主循环不断轮询并触发到期的任务：

import schedule

class AutoHealScheduler:
    """自愈式定时任务调度器"""

    def __init__(self, feishu_webhook: str = "", dingtalk_webhook: str = ""):
        self.tasks: list[tuple[schedule.Job, TaskSpec]] = []
        self.feishu_webhook = feishu_webhook
        self.dingtalk_webhook = dingtalk_webhook

    def add_cron(self, task: TaskSpec, cron_expr: str) -> None:
        """添加定时任务。cron_expr 示例: '0 9 * * *' (每天 9 点)"""
        hour, minute = cron_expr.split()[1], cron_expr.split()[0]
        if cron_expr.startswith("0"):  # 简化：仅支持「每天 X 点」
            job = schedule.every().day.at(f"{hour.zfill(2)}:{minute.zfill(2)}").do(
                lambda t=task: self._execute(t)
            )
        self.tasks.append((job, task))
        logger.info(f"已注册任务: {task.name} -> {cron_expr}")

    def _execute(self, task: TaskSpec) -> None:
        """触发一次任务执行 + 自愈 + 告警"""
        success = run_with_retry(task)
        if not success:
            send_feishu_alert(self.feishu_webhook, task)
            send_dingtalk_alert(self.dingtalk_webhook, task)

    def run(self) -> None:
        """启动调度器主循环"""
        logger.info("自愈式调度器已启动，等待触发...")
        while True:
            schedule.run_pending()
            time.sleep(1)

⚠️ schedule 的每天定时在跨午夜场景下有边界问题，生产环境建议换成 APScheduler 的 CronTrigger，用法几乎一样。

步骤 5：完整可运行示例

下面是一个可以直接 python main.py 跑起来的完整脚本，包含模拟的「数据同步任务」：

# main.py --- 复制粘贴即可运行
import logging
from datetime import datetime
import random

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s"
)

# ── 1. 模拟业务任务（实际替换为你的真实逻辑）────────────
def sync_daily_report():
    """模拟每天的数据同步，30% 概率随机失败"""
    if random.random() < 0.3:
        raise ConnectionError("上游 API 暂时不可用（模拟抖动）")
    print(f"[{datetime.now()}] 数据同步完成，写入 1,234 条记录")

# ── 2. 配置调度器 ───────────────────────────────────────
scheduler = AutoHealScheduler(
    feishu_webhook="https://open.feishu.cn/open-apis/bot/v2/hook/你的webhook",
    dingtalk_webhook="https://oapi.dingtalk.com/robot/send?access_token=你的token"
)

# 每天 9:00 执行，重试 3 次，退避 60s
task = TaskSpec(
    name="daily-report-sync",
    func=sync_daily_report,
    max_retries=3,
    backoff_base_seconds=60.0
)
scheduler.add_cron(task, "0 9 * * *")

# ── 3. 启动 ─────────────────────────────────────────────
if __name__ == "__main__":
    print("守护进程已启动。按 Ctrl+C 退出")
    try:
        scheduler.run()
    except KeyboardInterrupt:
        print("调度器已停止")

步骤 6：扩展能力清单

这个框架留好了扩展点，按需加即可：

扩展方向	改哪里	一句话
断点续跑	TaskSpec 加 last_success 字段，任务逻辑读上次时间	失败了从上次成功处继续
多任务并发	APScheduler 的 Blocker 或 asyncio	多个任务互不阻塞
配置外部化	把 Webhook 和任务列表读到 YAML/环境变量	不用改代码换环境
重试日志归档	失败时 append 到 failures.jsonl	事后分析失败模式
限流兜底	任务加 time.sleep(0.5) 请求间间隔	避免触发上游限流

总结

今天实战做了一个纯 Python 的自愈式定时任务框架，核心逻辑不到 80 行，却能覆盖生产中最常见的三类故障：

1. 短暂抖动 → 指数退避重试自动兜住，你甚至不知道它失败过

2. 持续故障 → 飞书/钉钉告警第一时间通知你

3. 跨天缺失 → 结合 last_success 字段，下次成功时补跑缺失时段

比起 crontab 的「盲跑」模式，这套框架的价值不在于代码多复杂，而在于把失败从「静默丢数据」变成了「可观测、可恢复、可告警」。

下次写定时脚本时，别只写 cron + python xxx.py，加上这几行自愈逻辑，你的任务可靠性会立刻上一个台阶。代码已贴全，复制就能用，今晚就开始给你的任务穿上防弹衣。