Run Monthly Tasks at 3 AM Every First Day | CronBase

#!/usr/bin/env bash
set -euo pipefail

# Define the cron schedule and command
CRON_SCHEDULE="0 3 1 * *"
JOB_COMMAND="/usr/local/bin/monthly-report-generator"

# Install the cron job safely without overwriting existing jobs
if ! crontab -l 2>/dev/null | grep -Fq "$JOB_COMMAND"; then
  (crontab -l 2>/dev/null; echo "$CRON_SCHEDULE $JOB_COMMAND --env production >> /var/log/cron-monthly.log 2>&1") | crontab -
  echo "[INFO] Monthly cron job successfully installed."
else
  echo "[WARN] Cron job already exists. Skipping installation."
fi

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

// Schedule task for 3:00 AM on the 1st of every month
cron.schedule('0 3 1 * *', async () => {
  console.log('[INFO] Starting monthly database archival process...');
  try {
    // Execute the archival script
    exec('/usr/local/bin/archive-db.sh', (error, stdout, stderr) => {
      if (error) {
        console.error(`[ERROR] Execution failed: ${error.message}`);
        return;
      }
      if (stderr) {
        console.warn(`[WARN] Standard error output: ${stderr}`);
      }
      console.log(`[SUCCESS] Output: ${stdout}`);
    });
  } catch (err) {
    console.error('[FATAL] Failed to trigger monthly archival job:', err);
  }
}, {
  scheduled: true,
  timezone: "UTC"
});

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

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger('MonthlyScheduler')

def run_monthly_billing():
    logger.info("Initiating monthly billing run...")
    try:
        # Simulate business logic execution
        pass
        logger.info("Monthly billing run completed successfully.")
    except Exception as e:
        logger.error(f"Monthly billing execution failed: {str(e)}")
        sys.exit(1)

if __name__ == '__main__':
    scheduler = BlockingScheduler(timezone='UTC')
    # 0 3 1 * * translates to: minute 0, hour 3, day of month 1
    scheduler.add_job(run_monthly_billing, 'cron', day=1, hour=3, minute=0)
    logger.info("Scheduler started. Waiting for execution on the 1st of the month at 3 AM UTC...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	// Use UTC to avoid daylight saving time anomalies
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load UTC location: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))
	
	// "0 3 1 * *" is represented in robfig/cron as "0 3 1 * *"
	_, err = c.AddFunc("0 3 1 * *", func() {
		log.Println("[INFO] Executing monthly ledger consolidation...")
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Hour)
		defer cancel()
		
		if err := performConsolidation(ctx); err != nil {
			log.Printf("[ERROR] Ledger consolidation failed: %v", err)
		} else {
			log.Println("[INFO] Ledger consolidation finished successfully.")
		}
	})
	if err != nil {
		log.Fatalf("Error scheduling monthly job: %v", err)
	}

	c.Start()
	log.Println("[INFO] Cron engine running. Monthly job scheduled.")

	stop := make(chan os.Signal, 1)
	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
	<-stop
	c.Stop()
}

func performConsolidation(ctx context.Context) error {
	// Real implementation 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 MonthlyMaintenanceScheduler {

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

    // "0 3 1 * *" maps to standard Spring Cron: "second minute hour day-of-month month day-of-week"
    // We specify zone as UTC to ensure consistency across cloud environments.
    @Scheduled(cron = "0 0 3 1 * *", zone = "UTC")
    public void runMonthlyMaintenance() {
        logger.info("Starting scheduled monthly maintenance routine...");
        try {
            executeMaintenanceTasks();
            logger.info("Monthly maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Critical failure during monthly maintenance run: ", e);
            // Trigger alerts/pagerduty integrations here
        }
    }

    private void executeMaintenanceTasks() throws Exception {
        // Your complex business logic here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: monthly-data-purge
  namespace: production
spec:
  schedule: "0 3 1 * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: purger
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "psql -h db-host -U postgres -d main_db -c 'SELECT purge_old_partitions();'"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure