Schedule Weekly Monday Morning Tasks | CronBase

const cron = require('node-cron');
const { exec } = require('child_process');

console.log('Registering weekly Monday morning cron runner...');

// Schedule task to run at 07:00 every Monday
const task = cron.schedule('0 7 * * 1', () => {
  console.log(`[${new Date().toISOString()}] Initiating weekly report compilation...`);
  
  exec('/usr/bin/node /app/scripts/generate-weekly-reports.js', (error, stdout, stderr) => {
    if (error) {
      console.error(`[ERROR] Report generation failed: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`[WARN] Standard error output: ${stderr}`);
    }
    console.log(`[SUCCESS] Reports sent successfully: ${stdout.trim()}`);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

#!/usr/bin/env bash

# Exit immediately if a command exits with a non-zero status
set -euo pipefail

LOG_FILE="/var/log/weekly_backup.log"

echo "[$(date -u)] Starting weekly Monday morning maintenance..." >> "$LOG_FILE"

# Add your production-ready script logic here
if /usr/local/bin/run-database-backup --compress --upload-s3; then
    echo "[$(date -u)] Maintenance completed successfully." >> "$LOG_FILE"
else
    echo "[$(date -u)] ERROR: Maintenance failed! Sending alert..." >&2
    # Trigger alerting mechanism (e.g., PagerDuty, Slack webhook)
    exit 1
fi

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

# Setup production logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def execute_weekly_sync():
    logging.info("Starting weekly external API synchronization...")
    try:
        # Place your production synchronization or API polling logic here
        logging.info("Synchronization completed successfully.")
    except Exception as e:
        logging.error(f"Failed to complete synchronization: {str(e)}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # Standard cron '0 7 * * 1' maps to day_of_week='mon', hour=7, minute=0
    trigger = CronTrigger(day_of_week='mon', hour=7, minute=0, timezone='UTC')
    scheduler.add_job(execute_weekly_sync, trigger=trigger, id='weekly_sync_job')
    
    logging.info("Scheduler initialized. Running weekly sync on Mondays at 07:00 UTC.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[CRON] ", log.LstdFlags|log.Lshortfile)

	// Use UTC to avoid daylight saving time issues
	location, err := time.LoadLocation("UTC")
	if err != nil {
		logger.Fatalf("Failed to load UTC timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(location))

	// AddFunc returns an entry ID and an error
	_, err = c.AddFunc("0 7 * * 1", func() {
		logger.Println("Executing weekly cache warmup routine...")
		// Perform HTTP cache warmup requests here
		logger.Println("Cache warmup routine completed successfully.")
	})
	if err != nil {
		logger.Fatalf("Error scheduling weekly job: %v", err)
	}

	c.Start()
	logger.Println("Cron engine started. Job scheduled for every Monday at 07:00 UTC.")

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

	logger.Println("Stopping cron engine...")
	c.Stop()
}

package com.cronbase.scheduler;

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

import java.time.Instant;

@Component
public class WeeklyMaintenanceScheduler {

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

    // Spring Cron expression includes seconds. "0 0 7 * * MON" executes at 07:00:00 every Monday.
    @Scheduled(cron = "0 0 7 * * MON", zone = "UTC")
    public void runWeeklyCleanup() {
        logger.info("Starting scheduled weekly database optimization at {}", Instant.now());
        try {
            // Implement your production database cleanup or index rebuild logic here
            logger.info("Weekly database optimization completed successfully.");
        } catch (Exception e) {
            logger.error("Critical error during weekly database optimization: ", e);
            // Trigger pager/alerting system
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-analytics-aggregation
  namespace: production
spec:
  schedule: "0 7 * * 1"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 1800
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: aggregator
            image: registry.example.com/analytics/aggregator:v1.4.2
            imagePullPolicy: IfNotPresent
            env:
            - name: NODE_ENV
              value: "production"
            resources:
              requests:
                cpu: "500m"
                memory: "512Mi"
              limits:
                cpu: "1000m"
                memory: "1Gi"
          restartPolicy: OnFailure