Bi-Monthly on the First at Midnight | CronBase

#!/usr/bin/env bash
# Production-ready Bash cron setup for bi-monthly tasks
set -euo pipefail

# Define the cron schedule
CRON_SCHEDULE="0 0 1 */2 *"
JOB_COMMAND="/usr/local/bin/archive-old-data.sh"

# Ensure the script runs with a lock to prevent concurrent executions
# and logs outputs to a dedicated file for auditability.
echo "Installing bi-monthly cron job..."
(crontab -l 2>/dev/null | grep -v "$JOB_COMMAND"; echo "$CRON_SCHEDULE /usr/bin/flock -n /var/lock/bi_monthly_archive.lock $JOB_COMMAND >> /var/log/cron_bi_monthly.log 2>&1") | crontab -

echo "Cron job installed successfully."

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

// Schedule bi-monthly task at 00:00 on the 1st of every other month
// Expression: 0 0 1 */2 *
const schedule = '0 0 1 */2 *';

const task = cron.schedule(schedule, async () => {
    console.log(`[${new Date().toISOString()}] Starting bi-monthly maintenance task...`);
    try {
        // Execute the maintenance task with proper error handling and timeout
        await runMaintenance();
        console.log(`[${new Date().toISOString()}] Bi-monthly task completed successfully.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] CRITICAL: Bi-monthly task failed:`, error);
        // In production, trigger an alert to PagerDuty, Slack, or Sentry here
    }
}, {
    scheduled: true,
    timezone: "UTC" // Force UTC to avoid Daylight Saving Time issues
});

async function runMaintenance() {
    return new Promise((resolve, reject) => {
        exec('/usr/local/bin/bi-monthly-cleanup.sh', (error, stdout, stderr) => {
            if (error) {
                reject(error);
                return;
            }
            resolve();
        });
    });
}

import logging
import sys
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',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def run_bi_monthly_job():
    logging.info("Starting bi-monthly data rotation job.")
    try:
        # Business logic goes here
        logging.info("Bi-monthly data rotation job completed successfully.")
    except Exception as e:
        logging.error(f"Failed to execute bi-monthly job: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # CronTrigger corresponds to standard "0 0 1 */2 *"
    # Executing at midnight (00:00) on the 1st day of every 2nd month
    trigger = CronTrigger(
        month='1,3,5,7,9,11',
        day=1,
        hour=0,
        minute=0,
        timezone='UTC'
    )
    
    scheduler.add_job(
        run_bi_monthly_job,
        trigger=trigger,
        id='bi_monthly_maintenance',
        replace_existing=True
    )
    
    logging.info("Starting scheduler for bi-monthly maintenance...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[BI-MONTHLY-JOB] ", log.LstdFlags|log.Lshortfile)

	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		logger.Fatalf("Failed to load UTC timezone: %v", err)
	}

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

	_, err = c.AddFunc("0 0 1 */2 *", func() {
		logger.Println("Starting bi-monthly database optimization...")
		defer func() {
			if r := recover(); r != nil {
				logger.Printf("CRITICAL: Panic recovered in job: %v", r)
			}
		}()

		if err := executeMaintenance(); err != nil {
			logger.Printf("ERROR: Maintenance task failed: %v", err)
		} else {
			logger.Println("Bi-monthly database optimization completed successfully.")
		}
	})

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

	c.Start()
	logger.Println("Scheduler started successfully. Waiting for execution...")

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

	logger.Println("Stopping scheduler gracefully...")
	c.Stop()
	logger.Println("Scheduler stopped.")
}

func executeMaintenance() 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;

import java.time.Instant;

@Component
public class BiMonthlyMaintenanceScheduler {

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

    /**
     * Executes a bi-monthly maintenance task at midnight on the first day of every other month.
     * Cron expression: 0 0 1 */2 *
     * timezone is set to UTC to guarantee consistent execution times.
     */
    @Scheduled(cron = "0 0 1 */2 *", zone = "UTC")
    public void executeBiMonthlyTask() {
        logger.info("Bi-monthly maintenance process started at {}", Instant.now());
        try {
            runMaintenanceRoutine();
            logger.info("Bi-monthly maintenance process completed successfully.");
        } catch (Exception ex) {
            logger.error("CRITICAL: Bi-monthly maintenance failed to execute", ex);
            sendAlertNotification(ex.getMessage());
        }
    }

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

    private void sendAlertNotification(String errorMessage) {
        // Code to send alerts to operations team
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: bimonthly-data-archiver
  namespace: maintenance
spec:
  # Run at midnight on the first day of every other month (0 0 1 */2 *)
  schedule: "0 0 1 */2 *"
  timeZone: "Etc/UTC"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: archiver
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - |
              set -e
              echo "Starting bi-monthly archive process..."
              psql -h $DB_HOST -U $DB_USER -d prod_db -c "SELECT rotate_partitions();"
              echo "Archive process completed successfully."
            env:
            - name: DB_HOST
              value: "postgres-service.database.svc.cluster.local"
            - name: DB_USER
              value: "postgres"
          restartPolicy: OnFailure