Quarterly Midnight Cron Job on the 15th | CronBase

#!/usr/bin/env bash
# Set up a system-wide cron entry in /etc/cron.d/quarterly-job
# Ensure the target script exists and has executable permissions

cat << 'EOF' > /etc/cron.d/quarterly-job
# Run the quarterly report script at midnight on the 15th of every 3rd month
0 0 15 */3 * root /usr/local/bin/run-quarterly-report.sh >> /var/log/quarterly-job.log 2>&1
EOF

chmod 0644 /etc/cron.d/quarterly-job
echo "Cron job successfully registered in /etc/cron.d/"

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

// Schedule task to run at 00:00 on day 15 of every 3rd month
cron.schedule('0 0 15 */3 *', () => {
  console.log('[INFO] Triggering quarterly database archiving task...');
  
  exec('/usr/local/bin/archive-quarterly-data.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`[ERROR] Execution failed: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`[WARN] Process stderr: ${stderr}`);
    }
    console.log(`[SUCCESS] Output: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

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

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('QuarterlyScheduler')

def run_quarterly_task():
    logger.info("Starting quarterly maintenance script...")
    try:
        result = subprocess.run(["/usr/local/bin/quarterly-cleanup.sh"], capture_output=True, text=True, check=True)
        logger.info(f"Task completed successfully: {result.stdout}")
    except subprocess.CalledProcessError as err:
        logger.error(f"Task failed with exit code {err.returncode}. Error: {err.stderr}")

scheduler = BlockingScheduler(timezone="UTC")
# standard cron fields: minute, hour, day, month, day_of_week
scheduler.add_job(run_quarterly_task, 'cron', month='*/3', day=15, hour=0, minute=0)

try:
    logger.info("Scheduler started. Waiting for next quarterly execution...")
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    logger.info("Scheduler stopped.")

package main

import (
	"log"
	"os/exec"
	"time"

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

func main() {
	// Use UTC timezone to guarantee consistency across DST shifts
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

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

	// Register the job using standard 5-field cron syntax
	_, err = c.AddFunc("0 0 15 */3 *", func() {
		log.Println("Executing scheduled quarterly routine...")
		cmd := exec.Command("/usr/local/bin/quarterly-audit")
		out, err := cmd.CombinedOutput()
		if err != nil {
			log.Printf("Error running quarterly routine: %v, Output: %s", err, string(out))
			return
		}
		log.Printf("Quarterly routine finished: %s", string(out))
	})
	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	select {} // Block main thread forever
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.logging.Logger;

@Component
public class QuarterlyTaskScheduler {

    private static final Logger LOGGER = Logger.getLogger(QuarterlyTaskScheduler.class.getName());

    // Spring Cron supports 6 fields: second, minute, hour, day, month, day-of-week
    @Scheduled(cron = "0 0 0 15 */3 *", zone = "UTC")
    public void executeQuarterlyJob() {
        LOGGER.info("Starting scheduled quarterly integration job...");
        try {
            Process process = Runtime.getRuntime().exec("/usr/local/bin/quarterly-sync.sh");
            int exitCode = process.waitFor();
            if (exitCode == 0) {
                LOGGER.info("Quarterly integration completed successfully.");
            } else {
                LOGGER.severe("Quarterly integration failed with exit code: " + exitCode);
            }
        } catch (IOException | InterruptedException e) {
            LOGGER.severe("Exception during quarterly job execution: " + e.getMessage());
            Thread.currentThread().interrupt();
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: quarterly-data-cleanup
  namespace: production
spec:
  schedule: "0 0 15 */3 *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: clean-worker
            image: python:3.10-slim
            command:
            - python
            - -c
            - "print('Running scheduled quarterly data retention script...')"
          restartPolicy: OnFailure