Run Jobs Monthly on the First Day at 1 AM | CronBase

#!/usr/bin/env bash
set -euo pipefail
# Production wrapper script for monthly database archival
# Designed to be triggered by cron: 0 1 1 * *
LOG_FILE="/var/log/db_archive_monthly.log"
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Starting monthly database archival..." >> "$LOG_FILE"
if ! pg_dump -U db_user -h localhost prod_db | gzip > "/backups/db_backup_$(date +'%Y-%m-%d').sql.gz"; then
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] ERROR: Backup failed!" >&2
    exit 1
fi
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Archival completed successfully." >> "$LOG_FILE"

const cron = require('node-cron');
const logger = require('./utils/logger');
const { processMonthlyBilling } = require('./services/billing');

// Schedule: 0 1 1 * * (At 01:00 on day-of-month 1)
const monthlyBillingJob = cron.schedule('0 1 1 * *', async () => {
  logger.info('Starting monthly billing job execution...');
  try {
    const result = await processMonthlyBilling();
    logger.info(`Monthly billing completed. Invoices processed: ${result.processedCount}`);
  } catch (error) {
    logger.error('Critical failure in monthly billing job:', error);
  }
}, {
  scheduled: true,
  timezone: "UTC"
});

monthlyBillingJob.start();

import logging
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler
from my_app.tasks import generate_monthly_reports

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

def execute_monthly_report_generation():
    logger.info("Triggering monthly report generation task...")
    try:
        report_path = generate_monthly_reports()
        logger.info(f"Monthly reports successfully generated at: {report_path}")
    except Exception as e:
        logger.error(f"Failed to generate monthly reports: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler(timezone="UTC")
    scheduler.add_job(
        execute_monthly_report_generation,
        'cron',
        day=1,
        hour=1,
        minute=0,
        id='monthly_reporting_job'
    )
    logger.info("Scheduler initialized. Monthly reporting job registered.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler shutting down gracefully.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[MonthlyJob] ", log.LstdFlags|log.Lshortfile)
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 1 1 * *", func() {
		logger.Println("Executing monthly system reconciliation...")
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Hour)
		defer cancel()

		if err := runReconciliation(ctx); err != nil {
			logger.Printf("ERROR: Reconciliation failed: %v\n", err)
		} else {
			logger.Println("Reconciliation completed successfully.")
		}
	})

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

	c.Start()
	logger.Println("Cron scheduler started successfully.")

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan

	logger.Println("Shutting down cron scheduler...")
	c.Stop()
}

func runReconciliation(ctx context.Context) error {
	time.Sleep(5 * 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 MonthlyMaintenanceScheduler {

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

    /**
     * Cron Expression: 0 1 1 * *
     * Runs at 01:00 AM on the 1st of every month.
     * Force UTC timezone to ensure consistent execution regardless of host OS timezone.
     */
    @Scheduled(cron = "0 0 1 1 * *", zone = "UTC")
    public void runMonthlyCleanup() {
        logger.info("Starting monthly database table partition maintenance...");
        try {
            performPartitionCleanup();
            logger.info("Monthly partition maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Failed to complete monthly cleanup tasks: ", e);
        }
    }

    private void performPartitionCleanup() throws Exception {
        Thread.sleep(10000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: monthly-data-archiver
  namespace: production
  labels:
    app: data-archiver
    tier: backend
spec:
  schedule: "0 1 1 * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 1800
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: data-archiver
        spec:
          restartPolicy: OnFailure
          containers:
          - name: archiver-task
            image: registry.example.com/data-tools:v2.1.0
            imagePullPolicy: IfNotPresent
            command: ["/bin/sh", "-c", "/app/run-archival.sh"]
            env:
            - name: DB_HOST
              value: "postgres-primary.production.svc.cluster.local"
            resources:
              limits:
                cpu: "1000m"
                memory: "2Gi"
              requests:
                cpu: "500m"
                memory: "1Gi"