Run Weekly Jobs on Wednesday at 9 AM | CronBase

#!/usr/bin/env bash
# Add this to your crontab using 'crontab -e'
# 0 9 * * 3 /usr/local/bin/wednesday_cleanup.sh >> /var/log/cron_wednesday.log 2>&1

set -euo pipefail

LOG_FILE="/var/log/cron_wednesday.log"
echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] Starting weekly Wednesday maintenance task..." >> "$LOG_FILE"

# Run the actual maintenance payload
if /usr/local/bin/perform_maintenance; then
    echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] Maintenance completed successfully." >> "$LOG_FILE"
else
    echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] ERROR: Maintenance task failed!" >> "$LOG_FILE"
    # Trigger alert payload here (e.g., Slack webhook or PagerDuty)
    exit 1
fi

const cron = require('node-cron');
const logger = require('./logger'); // Assume a production logger like Winston

// Schedule task to run every Wednesday at 9:00 AM
const task = cron.schedule('0 9 * * 3', async () => {
    logger.info('Starting weekly Wednesday report generation pipeline...');
    try {
        await runWeeklyReportPipeline();
        logger.info('Weekly Wednesday report generation completed successfully.');
    } catch (error) {
        logger.error('Failed to execute weekly Wednesday report pipeline', { error: error.message, stack: error.stack });
        // Handle alerting logic here
    }
}, {
    scheduled: true,
    timezone: "America/New_York" // Explicitly lock timezone to avoid DST drift issues
});

task.start();

import logging
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_midweek_sync():
    logger.info("Starting mid-week synchronization process...")
    try:
        # Your production business logic here
        pass
        logger.info("Mid-week synchronization completed successfully.")
    except Exception as e:
        logger.error(f"Sync process encountered an unhandled exception: {str(e)}", exc_info=True)
        # Trigger alerting system

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # standard cron pattern: minute=0, hour=9, day_of_week=2 (0 is Monday, 2 is Wednesday in APScheduler)
    trigger = CronTrigger(day_of_week='wed', hour=9, minute=0, timezone='UTC')
    scheduler.add_job(execute_midweek_sync, trigger=trigger, id='wednesday_9am_sync')
    
    logger.info("Starting scheduler daemon...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.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 the v3 cron package with support for standard 5-field cron spec
	loc, err := time.LoadLocation("UTC")
	if err != nil {
		logger.Fatalf("Failed to load UTC timezone: %v", err)
	}

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

	_, err = c.AddFunc("0 9 * * 3", func() {
		logger.Println("Executing Wednesday 9:00 AM batch task...")
		err := performBatchProcessing()
		if err != nil {
			logger.Printf("ERROR: Batch processing failed: %v", err)
			// Implement telemetry/alerting call here
		} else {
			logger.Println("Batch task completed successfully.")
		}
	})
	if err != nil {
		logger.Fatalf("Failed to schedule job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler started. Press Ctrl+C to exit.")

	// Keep application running until interrupted
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	logger.Println("Stopping cron scheduler...")
	c.Stop()
}

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

package com.example.cron;

import org.slf4j.Logger;

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

@Component
public class WednesdayCronJob {

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

    // Standard 6-field Spring cron syntax (seconds, minutes, hours, day of month, month, day of week)
    // "0 0 9 * * WED" runs every Wednesday at 9:00 AM
    @Scheduled(cron = "0 0 9 * * WED", zone = "UTC")
    public void executeWednesdayTask() {
        logger.info("Starting scheduled Wednesday 9:00 AM system diagnostic...");
        try {
            runDiagnosticSuite();
            logger.info("System diagnostic completed successfully.");
        } catch (Exception ex) {
            logger.error("Exception occurred during Wednesday diagnostic task execution: ", ex);
            // Trigger pager alarm notification
        }
    }

    private void runDiagnosticSuite() {
        // Production diagnostic logic here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: wednesday-reports-job
  namespace: production
spec:
  schedule: "0 9 * * 3"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: reporter
            image: registry.example.com/analytics/reporter:v1.2.0
            imagePullPolicy: IfNotPresent
            env:
            - name: NODE_ENV
              value: "production"
            resources:
              requests:
                cpu: "500m"
                memory: "512Mi"
              limits:
                cpu: "1"
                memory: "1Gi"
          restartPolicy: OnFailure