Run Monthly Jobs at 4 AM on Day 1 | CronBase

# Standard crontab entry to run a monthly cleanup script at 4:00 AM
# Ensure the output is redirected to a log file for auditing
0 4 1 * * /usr/local/bin/monthly_cleanup.sh >> /var/log/cron_monthly.log 2>&1

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

// Schedule task to run at 4:00 AM on the 1st of every month
cron.schedule('0 4 1 * *', () => {
  console.log('Starting monthly report generation...');
  exec('/usr/local/bin/generate_reports.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`Execution error: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`Warnings: ${stderr}`);
    }
    console.log(`Success: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

from apscheduler.schedulers.blocking import BlockingScheduler
import logging

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

def run_monthly_billing():
    logger.info("Executing monthly billing aggregation...")
    try:
        # Place billing business logic here
        pass
    except Exception as e:
        logger.error(f"Billing job failed: {str(e)}")

scheduler = BlockingScheduler(timezone="UTC")
# Trigger corresponding to '0 4 1 * *'
scheduler.add_job(run_monthly_billing, 'cron', day=1, hour=4, minute=0)

try:
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    pass

package main

import (
	"fmt"
	"log"
	"time"

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

func main() {
	// Use UTC to avoid DST complications
	nyc, _ := time.LoadLocation("UTC")
	c := cron.New(cron.WithLocation(nyc))

	_, err := c.AddFunc("0 4 1 * *", func() {
		fmt.Println("Running monthly database optimization...")
		if err := performMaintenance(); err != nil {
			log.Printf("Maintenance failed: %v", err)
		}
	})
	if err != nil {
		log.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	select {} // Keep application running
}

func performMaintenance() error {
	// Business 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 MonthlyMaintenanceScheduler {

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

    // Runs at 4:00 AM on the 1st of every month, using UTC timezone
    @Scheduled(cron = "0 4 1 * *", zone = "UTC")
    public void executeMonthlyTasks() {
        logger.info("Starting scheduled monthly data warehousing tasks...");
        try {
            // Implement data pipeline or archiving logic
        } catch (Exception e) {
            logger.error("Failed to complete monthly tasks: ", e);
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: monthly-data-backup
  namespace: production
spec:
  schedule: "0 4 1 * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup-worker
            image: postgres:15-alpine
            command: ["/bin/sh", "-c", "/scripts/backup-db.sh"]
            env:
            - name: DB_HOST
              value: "db-prod.internal"
          restartPolicy: OnFailure