Run Every Tuesday at 9 AM Schedule | CronBase

#!/usr/bin/env bash

# Ensure only one instance of the script runs at a time
LOCKFILE="/var/tmp/tuesday_weekly_job.lock"
exec 9>>"$LOCKFILE"
if ! flock -n 9; then
    echo "[$(date)] Job is already running. Exiting." >&2
    exit 1
fi

echo "[$(date)] Starting weekly Tuesday maintenance task..."

# Your production task here
if /usr/local/bin/run-weekly-report >> /var/log/tuesday_job.log 2>&1; then
    echo "[$(date)] Job completed successfully." 
else
    echo "[$(date)] Job failed! Sending alert..." >&2
    # Add alerting logic here (e.g., curl to Slack webhook)
    exit 1
fi

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

console.log('Scheduler initialized. Waiting for Tuesday 9:00 AM execution...');

// Schedule task to run every Tuesday at 9:00 AM
cron.schedule('0 9 * * 2', async () => {
    console.log(`[${new Date().toISOString()}] Initiating weekly report task...`);
    try {
        await runWeeklyTask();
        console.log(`[${new Date().toISOString()}] Weekly task finished successfully.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Job execution failed:`, error);
        // Integrate with Sentry, PagerDuty, or Slack here
    }
}, {
    scheduled: true,
    timezone: "Etc/UTC"
});

function runWeeklyTask() {
    return new Promise((resolve, reject) => {
        exec('/usr/local/bin/generate-reports', (error, stdout, stderr) => {
            if (error) {
                return reject(error);
            }
            resolve(stdout);
        });
    });
}

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',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def execute_weekly_job():
    logging.info("Starting weekly Tuesday maintenance job...")
    try:
        # Place production workload logic here
        logging.info("Weekly job successfully completed.")
    except Exception as e:
        logging.error(f"Error occurred during job execution: {str(e)}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # Trigger: Every Tuesday at 9:00 AM UTC
    trigger = CronTrigger(day_of_week='tue', hour=9, minute=0, timezone='UTC')
    scheduler.add_job(execute_weekly_job, trigger=trigger, id='weekly_tuesday_job')
    
    logging.info("Scheduler started. Waiting for next Tuesday 9:00 AM UTC...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped.")

package main

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

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

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

	// Use UTC timezone for predictable schedule behavior
	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 * * 2", func() {
		logger.Println("Executing scheduled Tuesday 9 AM task...")
		defer func() {
			if r := recover(); r != nil {
				logger.Printf("Recovered from panic in cron job: %v", r)
			}
		}()
		// Execute business logic here
		logger.Println("Scheduled Tuesday task completed successfully.")
	})

	if err != nil {
		logger.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	logger.Println("Cron scheduler active. Running every Tuesday at 9 AM UTC.")

	// 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()
}

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);

    // Standard Spring Cron: Second, Minute, Hour, Day-of-Month, Month, Day-of-Week
    // "0 0 9 * * TUE" translates to 9:00 AM every Tuesday
    @Scheduled(cron = "0 0 9 * * TUE", zone = "UTC")
    public void runWeeklyTuesdayTask() {
        logger.info("Initializing scheduled weekly Tuesday task...");
        try {
            performMaintenance();
            logger.info("Weekly Tuesday task executed successfully.");
        } catch (Exception e) {
            logger.error("Exception caught during weekly task execution: ", e);
            // Trigger pager alerts or system notifications here
        }
    }

    private void performMaintenance() throws Exception {
        // Your actual production database cleanup or reporting logic goes here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-tuesday-maintenance
  namespace: default
spec:
  schedule: "0 9 * * 2"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 1800
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: registry.example.com/maintenance-worker:latest
            imagePullPolicy: IfNotPresent
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "250m"
                memory: "256Mi"
          restartPolicy: OnFailure