Run Weekly Saturday Midnight Backups | CronBase

const cron = require('cron');
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  transports: [new winston.transports.Console()]
});

// Cron pattern for every Saturday at midnight
const job = new cron.CronJob('0 0 * * 6', async () => {
  logger.info('Starting scheduled weekly database maintenance...');
  try {
    // Perform database optimization and cleanup
    await performWeeklyMaintenance();
    logger.info('Weekly maintenance completed successfully.');
  } catch (error) {
    logger.error('Failed to execute weekly maintenance:', error);
  }
}, null, true, 'UTC');

async function performWeeklyMaintenance() {
  // Production-ready maintenance logic here
  return Promise.resolve();
}

job.start();

#!/usr/bin/env bash
set -euo pipefail
# Production Saturday Midnight Backup Script
BACKUP_DIR="/var/backups/weekly"
LOG_FILE="/var/log/weekly_backup.log"
exec > >(tee -ia "$LOG_FILE") 2>&1
echo "[$(date -u)] Starting weekly backup execution..."
if ! mkdir -p "$BACKUP_DIR"; then
  echo "Error: Failed to create backup directory" >&2
  exit 1
fi
# Simulate backup logic with error handling
if tar -czf "$BACKUP_DIR/data-$(date +%F).tar.gz" /data/db; then
  echo "[$(date -u)] Weekly backup completed successfully."
else
  echo "Error: Weekly backup failed!" >&2
  exit 1
fi

import logging
import sys
from apscheduler.schedulers.blocking import BlockingScheduler

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger(__name__)

def run_weekly_pipeline():
    logger.info("Starting weekly data pipeline execution...")
    try:
        # Implement production data pipeline or cleanup logic
        logger.info("Weekly data pipeline completed successfully.")
    except Exception as e:
        logger.error(f"Critical failure in weekly data pipeline: {str(e)}", exc_info=True)
        # In production, trigger external alerts here

scheduler = BlockingScheduler(timezone="UTC")
# 0 0 * * 6 translates to Saturday
scheduler.add_job(run_weekly_pipeline, 'cron', day_of_week='sat', hour=0, minute=0)

if __name__ == "__main__":
    try:
        logger.info("Starting scheduler for Saturday midnight job...")
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

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.LUTC)
	
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		logger.Fatalf("Failed to load timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))
	
	_, err = c.AddFunc("0 0 * * 6", func() {
		logger.Println("Starting weekly data sync...")
		if err := executeWeeklySync(); err != nil {
			logger.Printf("ERROR: Weekly sync failed: %v", err)
		} else {
			logger.Println("Weekly sync finished successfully.")
		}
	})
	if err != nil {
		logger.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler started successfully.")

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	logger.Println("Shutting down gracefully...")
	c.Stop()
}

func executeWeeklySync() error {
	// Production sync logic goes here
	return nil
}

package com.example.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);

    // Spring cron expression: second, minute, hour, day of month, month, day(s) of week
    @Scheduled(cron = "0 0 0 * * SAT", zone = "UTC")
    public void runWeeklyMaintenance() {
        logger.info("Starting scheduled weekly system maintenance...");
        try {
            executeMaintenanceTasks();
            logger.info("Weekly system maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Critical error during weekly system maintenance", e);
        }
    }

    private void executeMaintenanceTasks() throws Exception {
        // Business logic for weekly cleanup
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-database-cleanup
  namespace: production
spec:
  schedule: "0 0 * * 6"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec: 
      backoffLimit: 2
      template:
        spec:
          restartPolicy: OnFailure
          containers:
          - name: db-cleaner
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "vacuumdb -U postgres -d main_db --analyze --verbose"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
            resources:
              limits:
                cpu: "1"
                memory: 1Gi
              requests:
                cpu: "500m"
                memory: 512Mi