Run Monthly Jobs on the 28th at Midnight | CronBase

#!/usr/bin/env bash
# Production Bash script designed to run monthly on the 28th.
# Uses a lock file to prevent concurrent executions.
set -euo pipefail
LOCKFILE="/var/lock/monthly_ledger_run.lock"
exec 200>"$LOCKFILE"
flock -n 200 || { echo "Error: Another instance is running." >&2; exit 1; }

echo "[$(date -u)] Starting monthly financial ledger processing..."
# Call downstream service or run database cleanup
if ! curl -f -s -X POST https://api.internal/v1/ledger/close; then
    echo "Error: Ledger closure API call failed." >&2
    exit 1
fi
echo "[$(date -u)] Monthly task completed successfully."

const cron = require('node-cron');
const logger = require('./logger'); // Production logger abstraction

// Schedule task for 0 0 28 * * (Midnight on the 28th of every month)
cron.schedule('0 0 28 * *', async () => {
    logger.info('Starting monthly data archiving task...');
    try {
        await performMonthlyArchive();
        logger.info('Monthly data archiving completed successfully.');
    } catch (error) {
        logger.error('Failed to complete monthly archiving:', error);
        // Integrate notification hooks (e.g., Sentry, Slack, PagerDuty) here
    }
}, {
    scheduled: true,
    timezone: "UTC"
});

async function performMonthlyArchive() {
    // Simulate archive processing
    return new Promise((resolve) => setTimeout(resolve, 5000));
}

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')
logger = logging.getLogger('monthly_scheduler')

def run_monthly_billing():
    logger.info("Initiating monthly subscription billing run...")
    try:
        # Simulate billing processing
        logger.info("Monthly subscription billing completed successfully.")
    except Exception as e:
        logger.error(f"Critical error during monthly billing: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 0 28 * * -> minute=0, hour=0, day=28, month=*, day_of_week=*
    trigger = CronTrigger(minute=0, hour=0, day=28, timezone='UTC')
    scheduler.add_job(run_monthly_billing, trigger)
    logger.info("Scheduler initialized. Monthly job registered for the 28th at midnight UTC.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

package main

import (
	"context"
	"log"
	"time"

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

func main() {
	// Explicitly use UTC to avoid local system timezone discrepancies
	loc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load UTC location: %v", err)
	}

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

	// Schedule the standard cron spec: 0 0 28 * *
	_, err = c.AddFunc("0 0 28 * *", func() {
		log.Println("Starting monthly backup snapshot generation...")
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
		defer cancel()

		if err := executeMonthlyBackup(ctx); err != nil {
			log.Printf("CRITICAL: Monthly backup failed: %v", err)
		} else {
			log.Println("Monthly backup snapshot completed successfully.")
		}
	})

	if err != nil {
		log.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	log.Println("Cron runner started. Job scheduled for the 28th of every month at midnight.")
	select {} // Keep application running
}

func executeMonthlyBackup(ctx context.Context) error {
	// Simulate backup logic with timeout safety
	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 MonthlyReportScheduler {

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

    // Standard cron: 0 0 28 * * (Spring uses 6 fields: sec min hour day month day-of-week)
    @Scheduled(cron = "0 0 0 28 * *", zone = "UTC")
    public void executeMonthlyReport() {
        logger.info("Scheduled execution started: Monthly performance report generation.");
        try {
            generateReports();
            logger.info("Monthly performance report generation completed successfully.");
        } catch (Exception e) {
            logger.error("CRITICAL: Failed to generate monthly reports: ", e);
            // Trigger alerting infrastructure here
        }
    }

    private void generateReports() throws InterruptedException {
        // Simulate reporting logic
        Thread.sleep(5000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: monthly-data-reconciliation
  namespace: production
spec:
  schedule: "0 0 28 * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: reconciler
            image: internal-registry.corp/data-ops/reconciler:v1.4.2
            imagePullPolicy: IfNotPresent
            env:
            - name: ENVIRONMENT
              value: "production"
            resources:
              limits:
                cpu: "1000m"
                memory: "2Gi"
              requests:
                cpu: "500m"
                memory: "1Gi"
          restartPolicy: OnFailure