Schedule Monthly Tasks on the First at 9 AM | CronBase

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

// Schedule the task to run at 09:00 on day 1 of every month
cron.schedule('0 9 1 * *', async () => {
  console.log(`[${new Date().toISOString()}] Starting monthly billing aggregation...`);
  try {
    await runBillingPipeline();
    console.log(`[${new Date().toISOString()}] Monthly billing completed successfully.`);
  } catch (error) {
    console.error(`[${new Date().toISOString()}] CRITICAL: Monthly billing failed:`, error);
    // Integrate with incident response tooling (e.g., PagerDuty, Opsgenie) here
  }
}, {
  scheduled: true,
  timezone: "UTC"
});

async function runBillingPipeline() {
  return new Promise((resolve) => setTimeout(resolve, 5000));
}

#!/usr/bin/env bash
# System crontab entry using flock to prevent concurrent executions.
# Ensure the script runs with a lock and redirects output to a structured log file.
0 9 1 * * /usr/bin/flock -n /var/run/monthly_backup.lock /usr/local/bin/monthly_backup.sh >> /var/log/cron/monthly_backup.log 2>&1

import logging
from datetime import datetime
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(__name__)

def execute_monthly_data_sync():
    logger.info("Initiating monthly data synchronization pipeline.")
    try:
        # Business logic goes here
        logger.info("Monthly data synchronization completed successfully.")
    except Exception as e:
        logger.error(f"Failed monthly sync: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    trigger = CronTrigger(day=1, hour=9, minute=0, timezone='UTC')
    scheduler.add_job(execute_monthly_data_sync, trigger=trigger, id='monthly_sync_job')
    
    logger.info("Starting scheduler for monthly sync job...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[MonthlyJob] ", log.LstdFlags|log.Lshortfile)
	
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		logger.Fatalf("Failed to load timezone: %v", err)
	}

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

	_, err = c.AddFunc("0 9 1 * *", func() {
		logger.Println("Starting monthly database maintenance...")
		if err := runMaintenance(); err != nil {
			logger.Printf("ERROR: Maintenance failed: %v\n", err)
		} else {
			logger.Println("Monthly maintenance completed successfully.")
		}
	})
	if err != nil {
		logger.Fatalf("Failed to schedule job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler running, waiting for next execution...")

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

	logger.Println("Stopping scheduler...")
	c.Stop()
}

func runMaintenance() error {
	time.Sleep(2 * time.Second)
	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 MonthlyReportScheduler {

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

    // Standard cron mapping to Spring's 6-field syntax (second, minute, hour, day, month, day-of-week)
    @Scheduled(cron = "0 0 9 1 * *", zone = "UTC")
    public void generateMonthlyInvoices() {
        logger.info("Starting execution of monthly invoice generation pipeline.");
        try {
            processInvoices();
            logger.info("Monthly invoice generation completed successfully.");
        } catch (Exception e) {
            logger.error("Critical failure during monthly invoice generation", e);
        }
    }

    private void processInvoices() throws InterruptedException {
        Thread.sleep(5000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: monthly-data-cleanup
  namespace: production
spec:
  schedule: "0 9 1 * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup-executor
            image: alpine:3.18
            command:
            - /bin/sh
            - -c
            - "echo 'Starting monthly cleanup'; sleep 10; echo 'Cleanup finished'"
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "250m"
                memory: "256Mi"
          restartPolicy: OnFailure