Run Weekly Tasks Every Monday at Midnight | CronBase

const cron = require('node-cron');
const { exec } = require('child_process');
// Schedule: 0 0 * * 1 (Every Monday at midnight)
cron.schedule('0 0 * * 1', async () => {
    console.log(`[${new Date().toISOString()}] Initiating weekly cleanup task...`);
    try {
        await runWeeklyTask();
        console.log(`[${new Date().toISOString()}] Weekly task finished successfully.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Critical failure during weekly task:`, error);
        // In production, integrate with PagerDuty, Sentry, or Slack webhook alert here
    }
});
function runWeeklyTask() {
    return new Promise((resolve, reject) => {
        // Mock database optimization or cleanup
        setTimeout(() => resolve(), 5000);
    });
}

#!/usr/bin/env bash
set -euo pipefail
# Operational cron script for weekly backup/maintenance
LOCKFILE="/var/lock/weekly_maintenance.lock"
exec 200>"$LOCKFILE"
if ! flock -n 200; then
    echo "Error: Another instance of this weekly job is already running." >&2
    exit 1
fi
echo "[$(date -u)] Starting weekly maintenance task..."
# Add production business logic here
# Example: tar -czf /backups/weekly_$(date +%F).tar.gz /data
echo "[$(date -u)] Weekly maintenance completed successfully."

import logging
import sys
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def execute_weekly_job():
    logger.info("Starting scheduled weekly data reconciliation pipeline...")
    try:
        # Insert core business logic here (e.g., DB vacuuming, report compilation)
        logger.info("Weekly data reconciliation completed successfully.")
    except Exception as e:
        logger.error(f"Failed to execute weekly job: {str(e)}", exc_info=True)
        # Production environments should raise alerts to external monitoring systems here

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # Standard cron syntax: 0 0 * * 1 mapped to CronTrigger
    trigger = CronTrigger(day_of_week='mon', hour=0, minute=0, timezone='UTC')
    scheduler.add_job(execute_weekly_job, trigger=trigger, id='weekly_reconciliation')
    logger.info("Scheduler initialized. Waiting for Monday midnight UTC trigger...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")
        sys.exit(0)

package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/robfig/cron/v3"
)

func main() {
	logger := log.New(os.Stdout, "[WeeklyJob] ", log.LstdFlags|log.Lshortfile)
	
	// Initialize cron runner with UTC location to prevent DST confusion
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 0 * * 1", func() {
		logger.Println("Executing weekly database index optimization...")
		err := performMaintenance()
		if err != nil {
			logger.Printf("CRITICAL ERROR during weekly maintenance: %v\n", err)
			// Integrate alert/pager notification here
			return
		}
		logger.Println("Weekly database optimization completed successfully.")
	})

	if err != nil {
		logger.Fatalf("Failed to initialize cron job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler started. Monitoring for weekly Monday 00:00 UTC execution...")

	// Keep application running until interrupted
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan

	logger.Println("Shutting down scheduler...")
	c.Stop()
}

func performMaintenance() error {
	// Simulating production maintenance task
	time.Sleep(2 * time.Second)
	return nil
}

package com.cronbase.scheduler;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class WeeklyMaintenanceScheduler {

    private static final Logger logger = LoggerFactory.getLogger(WeeklyMaintenanceScheduler.class);

    /**
     * Schedules the weekly maintenance task.
     * Cron syntax: "0 0 0 * * MON" in Spring (seconds, minutes, hours, day-of-month, month, day-of-week)
     * Zone is explicitly set to UTC to guarantee stable execution across different infrastructure environments.
     */
    @Scheduled(cron = "0 0 0 * * MON", zone = "UTC")
    public void runWeeklyMaintenance() {
        logger.info("Initiating weekly security audit and log rotation process...");
        try {
            executeAuditSuite();
            logger.info("Weekly security audit and log rotation completed successfully.");
        } catch (Exception ex) {
            logger.error("CRITICAL: Weekly maintenance task failed!", ex);
            // Production recommendation: Trigger external incident management integration (e.g., Opsgenie)
        }
    }

    private void executeAuditSuite() throws Exception {
        // Simulate business logic execution
        Thread.sleep(1000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-database-cleanup
  namespace: production
spec:
  # Run every Monday at midnight (00:00)
  schedule: "0 0 * * 1"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 1800
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: maintenance-worker
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - |
              echo "Starting weekly database vacuuming..."
              vacuumdb -U postgres -h db-service.production.svc.cluster.local -a -z || exit 1
              echo "Weekly database vacuuming completed successfully."
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure