Run Every Wednesday at 10:00 AM | CronBase

const cron = require('node-cron');
const logger = require('pino')();

// Schedule to run every Wednesday at 10:00 AM UTC
cron.schedule('0 10 * * 3', async () => {
    logger.info('Starting weekly Wednesday data sync...');
    try {
        await executeSyncPipeline();
        logger.info('Weekly Wednesday data sync completed successfully.');
    } catch (error) {
        logger.error({ err: error }, 'Wednesday data sync failed.');
    }
}, {
    scheduled: true,
    timezone: "UTC"
});

async function executeSyncPipeline() {
    // Implementation of the mid-week sync logic
    return Promise.resolve();
}

#!/usr/bin/env bash
# To install this system-wide, add the following line to your crontab:
# 0 10 * * 3 /usr/local/bin/wednesday-cleanup.sh

set -euo pipefail

LOG_FILE="/var/log/wednesday_cleanup.log"
exec 3>&1 1>>"${LOG_FILE}" 2>&1

echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Wednesday morning cleanup job started."

# Perform a safe, non-blocking cleanup of temporary files
find /tmp/app-cache -type f -mtime +7 -delete || {
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Error: Cleanup failed." >&3
    exit 1
}

echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Wednesday cleanup 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',
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger(__name__)

def run_wednesday_job():
    logger.info("Starting scheduled Wednesday 10:00 AM task...")
    try:
        # Add production business logic here
        logger.info("Wednesday task completed successfully.")
    except Exception as e:
        logger.error(f"Wednesday task failed: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 10 * * 3 maps to day_of_week='wed', hour=10, minute=0
    trigger = CronTrigger(day_of_week='wed', hour=10, minute=0, timezone='UTC')
    scheduler.add_job(run_wednesday_job, trigger)
    logger.info("Scheduler initiated. Waiting for Wednesday 10:00 AM UTC...")
    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, "[WEDNESDAY-JOB] ", log.LstdFlags|log.Lshortfile)

	// Use UTC location to avoid DST shifts
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 10 * * 3", func() {
		logger.Println("Executing weekly sync pipeline...")
		if err := performSync(); err != nil {
			logger.Printf("Pipeline failed: %v\n", err)
			return
		}
		logger.Println("Pipeline execution completed successfully.")
	})
	if err != nil {
		logger.Fatalf("Failed to initialize scheduler: %v", err)
	}

	c.Start()
	logger.Println("Scheduler started. Running every Wednesday at 10:00 AM UTC.")

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

	logger.Println("Stopping scheduler...")
	c.Stop()
}

func performSync() error {
	// Simulating work
	time.Sleep(2 * time.Second)
	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 MidWeekScheduler {

    private static final Logger log = LoggerFactory.getLogger(MidWeekScheduler.class);

    // Spring uses 6-field cron patterns: "second minute hour day-of-month month day-of-week"
    // "0 0 10 * * WED" translates to 10:00:00 AM every Wednesday
    @Scheduled(cron = "0 0 10 * * WED", zone = "UTC")
    public void executeWednesdayTask() {
        log.info("Starting scheduled Wednesday 10:00 AM execution...");
        try {
            runBusinessLogic();
            log.info("Wednesday execution completed successfully.");
        } catch (Exception e) {
            log.error("Error occurred during Wednesday execution: ", e);
        }
    }

    private void runBusinessLogic() {
        // Application logic here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: wednesday-report-generator
  namespace: default
spec:
  schedule: "0 10 * * 3"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 2
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: generator
            image: python:3.11-slim
            command: ["python", "-c", "print('Generating Wednesday report...')"]
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "200m"
                memory: "256Mi"
          restartPolicy: OnFailure