Run Monthly System Tasks at Midnight | CronBase

#!/usr/bin/env bash

# Ensure the target script exists and is executable
CLEANUP_SCRIPT="/usr/local/bin/monthly_cleanup.sh"

if [ -f "$CLEANUP_SCRIPT" ]; then
  # Append the monthly cron job to the current user's crontab safely
  (crontab -l 2>/dev/null; echo "0 0 1 * * $CLEANUP_SCRIPT >> /var/log/monthly_cleanup.log 2>&1") | crontab -
  echo "Successfully scheduled monthly cleanup job."
else
  echo "Error: Target script $CLEANUP_SCRIPT not found. Cron job installation aborted." >&2
  exit 1
fi

const cron = require('node-cron');
const winston = require('winston');

// Configure a production-ready logger
const logger = winston.createLogger({
  level: 'info',
  transports: [new winston.transports.Console()]
});

// Schedule the task to run on the first day of every month at midnight in UTC
cron.schedule('0 0 1 * *', async () => {
  logger.info('Starting scheduled monthly billing processing...');
  try {
    await runMonthlyBilling();
    logger.info('Monthly billing completed successfully.');
  } catch (error) {
    logger.error('Critical failure during monthly billing execution:', error);
    // Implement paging or alerting system calls here
  }
}, {
  scheduled: true,
  timezone: "UTC"
});

async function runMonthlyBilling() {
  // Business logic for processing billing
  return Promise.resolve();
}

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 execute_monthly_report():
    logger.info("Starting monthly report generation...")
    try:
        # Simulating reporting job
        logger.info("Monthly report generated successfully.")
    except Exception as e:
        logger.error(f"Failed to generate monthly report: {e}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    trigger = CronTrigger(day=1, hour=0, minute=0, timezone='UTC')
    scheduler.add_job(execute_monthly_report, trigger=trigger, id='monthly_report_job')
    
    try:
        logger.info("Starting blocking scheduler for monthly tasks...")
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")
        sys.exit(0)

package main

import (
	"log"
	"time"

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

func main() {
	// Use UTC to prevent issues with Daylight Saving Time transitions
	loc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load UTC timezone: %v", err)
	}

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

	_, err = c.AddFunc("0 0 1 * *", func() {
		log.Println("Monthly backup sequence initiated...")
		if err := performBackup(); err != nil {
			log.Printf("CRITICAL ERROR: Monthly backup failed: %v", err)
		} else {
			log.Println("Monthly backup completed successfully.")
		}
	})
	if err != nil {
		log.Fatalf("Failed to schedule monthly job: %v", err)
	}

	c.Start()
	// Keep the process alive indefinitely
	select {}
}

func performBackup() error {
	// Real backup 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 MonthlyDataArchiver {

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

    // Standard 6-field Spring cron format: second, minute, hour, day, month, day-of-week
    @Scheduled(cron = "0 0 0 1 * *", zone = "UTC")
    public void archiveOldData() {
        logger.info("Monthly archival process started.");
        try {
            executeArchival();
            logger.info("Monthly archival completed successfully.");
        } catch (Exception e) {
            logger.error("CRITICAL: Monthly archival job failed!", e);
        }
    }

    private void executeArchival() throws Exception {
        // Perform data archival operations
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: monthly-database-pruner
  namespace: production
spec:
  schedule: "0 0 1 * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: db-pruner
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "psql $DATABASE_URL -c 'VACUUM ANALYZE;'"
            env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: db-secrets
                  key: url
          restartPolicy: OnFailure