Cron

https://pkg.go.dev/github.com/robfig/cron/v3
Admin
A Go package that implements a cron spec parser and job runner for scheduling tasks with support for...
Tokens:16,264
Snippets:207
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Go Cron Package

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Download the specific tagged release of the cron package using go get. Requires Go 1.11 or later.

```bash
go get github.com/robfig/cron/v3@v3.0.0
```

--------------------------------

### Start Cron Scheduler

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Starts the cron scheduler in a separate goroutine. If it's already started, this is a no-operation.

```go
func (c *Cron) Start()
```

--------------------------------

### Standard Cron Parser Examples

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Demonstrates creating `Parser` instances with different `ParseOption` configurations for parsing cron specifications.

```go
// Standard parser without descriptors
specParser := NewParser(Minute | Hour | Dom | Month | Dow)
sched, err := specParser.Parse("0 0 15 */3 *")
```

```go
// Same as above, just excludes time fields
subsParser := NewParser(Dom | Month | Dow)
sched, err := specParser.Parse("15 */3 *")
```

```go
// Same as above, just makes Dow optional
subsParser := NewParser(Dom | Month | DowOptional)
sched, err := specParser.Parse("15 */3")
```

--------------------------------

### Basic Cron Usage

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Demonstrates how to create a new cron instance, add functions with different schedule formats, start the scheduler, and stop it.

```go
c := cron.New()
c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println(".. in the range 3-6am, 8-11pm") })
c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })
c.AddFunc("@hourly",      func() { fmt.Println("Every hour, starting an hour from now") })
c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })
c.Start()
..
// Funcs are invoked in their own goroutine, asynchronously.
...
// Funcs may also be added to a running Cron
c.AddFunc("@daily", func() { fmt.Println("Every day") })
..
// Inspect the cron job entries' next and previous run times.
inspect(c.Entries())
..
c.Stop()  // Stop the scheduler (does not stop any jobs already running).

```

--------------------------------

### Cron.Run

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Starts the cron scheduler. If it is already running, this method is a no-op.

```APIDOC
## Cron.Run

### Description
Starts the cron scheduler. If it is already running, this method is a no-op.

### Signature
```go
func (c *Cron) Run()
```
```

--------------------------------

### Cron.Start

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Starts the cron scheduler in its own goroutine. If it is already started, this method is a no-op.

```APIDOC
## Cron.Start

### Description
Starts the cron scheduler in its own goroutine. If it is already started, this method is a no-op.

### Signature
```go
func (c *Cron) Start()
```
```

--------------------------------

### Basic Cron Job Scheduling

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Demonstrates how to create a new cron scheduler, add functions to run on specific schedules, start the scheduler, and stop it. Functions are invoked in their own goroutines.

```go
c := cron.New()
c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println(".. in the range 3-6am, 8-11pm") })
c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })
c.AddFunc("@hourly",      func() { fmt.Println("Every hour, starting an hour from now") })
c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })
c.Start()
..
// Funcs are invoked in their own goroutine, asynchronously.
...
// Funcs may also be added to a running Cron
c.AddFunc("@daily", func() { fmt.Println("Every day") })
..
// Inspect the cron job entries' next and previous run times.
inspect(c.Entries())
..
c.Stop()  // Stop the scheduler (does not stop any jobs already running).
```

--------------------------------

### Configure Cron with Verbose Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Use the WithLogger option to specify a logger that does not discard Info logs. This example shows how to wrap a standard *log.Logger for convenience.

```go
cron.New(
    cron.WithLogger(cron.VerbosePrintfLogger(logger)))


```

--------------------------------

### Cron Control

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Functions to start, stop, and run the cron scheduler.

```APIDOC
## Cron

### Start

```go
func (c *Cron) Start()
```

Start starts the cron scheduler in the background. 

### Stop

```go
func (c *Cron) Stop() context.Context
```

Stop stops the cron scheduler. It stops all jobs that are currently running and prevents new jobs from starting. 

### Run

```go
func (c *Cron) Run()
```

Run runs the cron scheduler's jobs that are ready to run. This is useful for running jobs on demand, or for testing.
```

--------------------------------

### Get All Cron Entries

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Entries returns a snapshot of all currently scheduled cron entries.

```go
func (c *Cron) Entries() []Entry
```

--------------------------------

### Custom Cron Parser with Seconds Field

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Implement a custom cron parser to support additional fields like seconds. This example shows how to enable the seconds field using cron.SecondOptional.

```go
cron.New(
	cron.WithParser(
		cron.NewParser(
			cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)))


```

--------------------------------

### Get Cron Entries

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Retrieves a snapshot of all currently scheduled cron entries. This can be used to inspect the state of the running cron scheduler.

```go
entries := c.Entries()
for _, entry := range entries {
	fmt.Println(entry)
}
```

--------------------------------

### Get Cron Entry Snapshot

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Retrieves a snapshot of a specific cron entry by its ID. Returns nil if the entry is not found.

```go
func (c *Cron) Entry(id EntryID) Entry
```

--------------------------------

### Initialize Cron with Options

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Shows how to create a new Cron instance with custom options such as time zone, parser, and job wrappers. Use cron.With* functions to modify defaults.

```go
c := New()
c = New(WithSeconds())
```

--------------------------------

### Create a Parser with Options

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Initializes a new Parser with specified options, allowing customization of how cron specifications are interpreted. Use ParseOption constants for configuration.

```go
p := NewParser(ParseOption{})

```

--------------------------------

### Create a New Cron Instance

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Initialize a new Cron job runner with optional configurations like time zone, parser, and job wrappers.

```go
func New(opts ...Option) *Cron
```

--------------------------------

### Create and Decorate a Job with Chain

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Demonstrates how to create a Chain of JobWrappers and apply it to a Job. This is equivalent to nested function calls.

```go
m1(m2(m3(job)))
```

--------------------------------

### Cron.Location

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Gets the time zone location configured for the cron instance.

```APIDOC
## Cron.Location

### Description
Gets the time zone location configured for the cron instance.

### Method
GET (conceptual)

### Endpoint
N/A (Method Call)

### Response
#### Success Response (200)
- **Location** (*time.Location) - The time zone location of the cron instance.
```

--------------------------------

### Cron.Location

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Gets the current time zone location configured for the cron instance.

```APIDOC
## Cron.Location

### Description
Gets the current time zone location configured for the cron instance.

### Signature
```go
func (c *Cron) Location() *time.Location
```

### Returns
- **time.Location**: The time zone location of the cron instance.
```

--------------------------------

### Get Cron Time Zone Location

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns the time zone location used by the cron scheduler.

```go
func (c *Cron) Location() *time.Location
```

--------------------------------

### Create a New Chain of Job Wrappers

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Use NewChain to create a sequence of JobWrappers. This chain can then be used to decorate jobs with cross-cutting behaviors.

```go
func NewChain(c ...JobWrapper) Chain
```

--------------------------------

### Cron Initialization

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Initializes a new Cron job runner with optional configurations.

```APIDOC
## Cron

### Description
Cron keeps track of any number of entries, invoking the associated func as specified by the schedule. It may be started, stopped, and the entries may be inspected while running.

### New

```go
func New(opts ...Option) *Cron
```

New returns a new Cron job runner, modified by the given options.

Available Settings:
- Time Zone: The time zone in which schedules are interpreted. Default: time.Local
- Parser: Parser converts cron spec strings into cron.Schedules. Default: Accepts this spec: https://en.wikipedia.org/wiki/Cron
- Chain: Wrap submitted jobs to customize behavior. Default: A chain that recovers panics and logs them to stderr.

See "cron.With*" to modify the default behavior.
```

--------------------------------

### Cron Options

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Options for configuring the Cron instance.

```APIDOC
## Option

### WithChain

```go
func WithChain(wrappers ...JobWrapper) Option
```

WithChain returns an Option that sets the job wrappers for the cron instance.

### WithLocation

```go
func WithLocation(loc *time.Location) Option
```

WithLocation returns an Option that sets the time zone for the cron instance.

### WithLogger

```go
func WithLogger(logger Logger) Option
```

WithLogger returns an Option that sets the logger for the cron instance.

### WithParser

```go
func WithParser(p ScheduleParser) Option
```

WithParser returns an Option that sets the parser for the cron instance.

### WithSeconds

```go
func WithSeconds() Option
```

WithSeconds returns an Option that enables seconds in the cron spec.
```

--------------------------------

### NewParser

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a new Parser with custom configuration options. Panics if multiple optional fields are provided.

```APIDOC
## NewParser

### Description
Creates a new Parser with custom configuration options. Panics if multiple optional fields are provided.

### Function Signature
```go
func NewParser(options ParseOption) Parser
```

### Parameters
* **options** (*ParseOption*) - A bitmask of ParseOption constants to configure the parser.

### Examples
```go
// Standard parser without descriptors
specParser := NewParser(Minute | Hour | Dom | Month | Dow)
sched, err := specParser.Parse("0 0 15 */3 *")

// Same as above, just excludes time fields
subsParser := NewParser(Dom | Month | Dow)
sched, err := specParser.Parse("15 */3 *")

// Same as above, just makes Dow optional
subsParser := NewParser(Dom | Month | DowOptional)
sched, err := specParser.Parse("15 */3")
```
```

--------------------------------

### Configure Cron with Panic Recovery

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Opt into panic recovery for jobs and configure the panic logger using the WithChain option. This is recommended for production environments to prevent job panics from crashing the application.

```go
cron.New(cron.WithChain(
    cron.Recover(logger),  // or use cron.DefaultLogger
))


```

--------------------------------

### Create Cron with Seconds Field Enabled (Standard)

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Construct a new Cron instance with the seconds field enabled, adhering to the standard cron specification.

```go
cron.New(cron.WithSeconds())

```

--------------------------------

### Create a Printf Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Logger that prints information using a Printf-style interface. This is a basic logger implementation for cron jobs.

```go
PrintfLogger(l)
```

--------------------------------

### Cron Option: With Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option that sets a custom logger for the cron instance.

```go
func WithLogger(logger Logger) Option
```

--------------------------------

### Cron Parse Options

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Define configuration options for creating custom cron parsers. These options specify which fields are included and enable specific features.

```go
type ParseOption int
```

```go
const (
	Second         ParseOption = 1 << iota // Seconds field, default 0
	SecondOptional                         // Optional seconds field, default 0
	Minute                                 // Minutes field, default 0
	Hour                                   // Hours field, default 0
	Dom                                    // Day of month field, default *
	Month                                  // Month field, default *
	Dow                                    // Day of week field, default *
	DowOptional                            // Optional day of week field, default *
	Descriptor                             // Allow descriptors such as @monthly, @weekly, etc.
)
```

--------------------------------

### Run FuncJob

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Executes the wrapped function for a FuncJob.

```go
func (f FuncJob) Run()
```

--------------------------------

### Create a Constant Delay Schedule

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Use Every to create a schedule that triggers a job at a fixed interval. Delays less than one second are rounded up to one second.

```go
func Every(duration time.Duration) ConstantDelaySchedule
```

--------------------------------

### Create a DelayIfStillRunning Job Wrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a JobWrapper that delays the execution of a job if it is already running. The job will be executed after the current instance finishes.

```go
DelayIfStillRunning(logger)
```

--------------------------------

### Create Custom Cron Parser

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a cron parser with custom options. It panics if more than one Optional field is provided, as this can lead to ambiguity. Use this to define parsers that include or exclude specific fields or allow optional fields.

```go
specParser := NewParser(Minute | Hour | Dom | Month | Dow)
sched, err := specParser.Parse("0 0 15 */3 *")
```

```go
subsParser := NewParser(Dom | Month | Dow)
sched, err := specParser.Parse("15 */3 *")
```

```go
subsParser := NewParser(Dom | Month | DowOptional)
sched, err := specParser.Parse("15 */3")
```

--------------------------------

### Create a New Schedule Parser

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

NewParser creates a Parser with the given options, which can then be used to parse cron spec strings.

```go
func NewParser(options ParseOption) Parser
```

--------------------------------

### Enable Panic Recovery with JobWrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Configure a new Cron instance to recover panics from jobs using the Recover JobWrapper and specify a logger for panic events.

```go
cron.New(cron.WithChain(
    cron.Recover(logger),  // or use cron.DefaultLogger
))

```

--------------------------------

### Create a Constant Delay Schedule

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a schedule that activates once every specified duration. Delays less than a second are rounded up to one second, and sub-second fields are truncated.

```go
Every(time.Hour)
```

--------------------------------

### Create Cron with Custom Parser (Seconds Optional)

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Construct a new Cron instance with a custom parser that makes the seconds field optional, along with other standard cron fields.

```go
cron.New(
    cron.WithParser(
        cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor))

```

--------------------------------

### Import Cron V3 in Go Program

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Import the cron V3 package into your Go program using this import path.

```go
import "github.com/robfig/cron/v3"

```

--------------------------------

### WithChain

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Specifies Job wrappers to apply to all jobs added to this cron instance. Uses provided Chain* functions for wrappers.

```APIDOC
## WithChain

### Description
Specifies Job wrappers to apply to all jobs added to this cron instance. Uses provided Chain* functions for wrappers.

### Signature
```go
func WithChain(wrappers ...JobWrapper) Option
```

### Parameters
#### Path Parameters
- **wrappers** (...JobWrapper) - A variadic list of Job wrappers.
```

--------------------------------

### Cron Parser Options

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Defines configuration options for creating a custom cron parser. These options specify which fields (seconds, minutes, hours, day of month, month, day of week) are included and whether they are optional. The Descriptor option allows for special descriptors like @monthly.

```go
const (
	Second         ParseOption = 1 << iota // Seconds field, default 0
	SecondOptional                         // Optional seconds field, default 0
	Minute                                 // Minutes field, default 0
	Hour                                   // Hours field, default 0
	Dom                                    // Day of month field, default *
	Month                                  // Month field, default *
	Dow                                    // Day of week field, default *
	DowOptional                            // Optional day of week field, default *
	Descriptor                             // Allow descriptors such as @monthly, @weekly, etc.
)
```

--------------------------------

### Cron Option: With Chain

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option that specifies a chain of JobWrappers to be applied to all jobs added to the cron instance. Use Chain* functions for provided wrappers.

```go
func WithChain(wrappers ...JobWrapper) Option
```

--------------------------------

### Create a Verbose Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Logger that prints verbose information, useful for debugging. It requires an underlying logger interface that supports fmt.Printf-like functionality.

```go
VerbosePrintfLogger(l)
```

--------------------------------

### Run Cron Scheduler

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Executes the cron scheduler. If it's already running, this is a no-operation.

```go
func (c *Cron) Run()
```

--------------------------------

### Import Go Cron Package

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Import the cron package into your Go program. This package requires Go Modules support.

```go
import "github.com/robfig/cron/v3"
```

--------------------------------

### Schedule a Job with Cron

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Adds a job to the cron scheduler to be executed according to the provided schedule. The job is automatically wrapped with the configured chain.

```go
func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID
```

--------------------------------

### Use Verbose Logging with a Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Create a new Cron instance with verbose logging enabled by wrapping a standard logger. This ensures that Info logs are not discarded.

```go
cron.New(
    cron.WithLogger(cron.VerbosePrintfLogger(logger)))

```

--------------------------------

### Cron Schedule Interface

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Defines the `Schedule` interface, which describes a job's duty cycle. The `Next` method returns the next activation time.

```go
type Schedule interface {
	// Next returns the next activation time, later than the given time.
	// Next is invoked initially, and then each time the job is run.
	Next(time.Time) time.Time
}
```

--------------------------------

### Logger Utilities

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Functions for creating logger instances.

```APIDOC
## Logger

### PrintfLogger

```go
func PrintfLogger(l interface{ ... }) Logger
```

PrintfLogger returns a Logger that writes to the given Printf-like interface.

### VerbosePrintfLogger

```go
func VerbosePrintfLogger(l interface{ ... }) Logger
```

VerbosePrintfLogger returns a Logger that writes to the given Printf-like interface, including verbose logging.
```

--------------------------------

### DelayIfStillRunning

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a job wrapper that serializes jobs, delaying subsequent runs until the previous one is complete. Logs delays longer than a minute.

```APIDOC
## DelayIfStillRunning

### Description
Creates a job wrapper that serializes jobs, delaying subsequent runs until the previous one is complete. Logs delays longer than a minute.

### Signature
```go
func DelayIfStillRunning(logger Logger) JobWrapper
```

### Parameters
#### Path Parameters
- **logger** (Logger) - The logger to use for logging delays.
```

--------------------------------

### Cron Parser with Required Seconds Field (Quartz Emulation)

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Use the built-in cron.WithSeconds() option to create a parser that requires a seconds field, emulating the Quartz scheduler format. This is useful for Java-based cron scheduling compatibility.

```go
cron.New(cron.WithSeconds())
```

--------------------------------

### Create a Recover Job Wrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a JobWrapper that recovers from panics in the wrapped job and logs them. This helps prevent a single job failure from crashing the entire cron process.

```go
Recover(logger)
```

--------------------------------

### Chaining Job Wrappers in Cron

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Apply multiple job wrappers to all jobs added to a cron instance using cron.WithChain. This allows for adding cross-cutting functionality like skipping already running jobs.

```go
cron.New(cron.WithChain(
	cron.SkipIfStillRunning(logger),
))

```

--------------------------------

### Download Cron V3

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Use this command to download the specific tagged release of cron V3.

```bash
go get github.com/robfig/cron/v3@v3.0.0

```

--------------------------------

### Calculate Next Activation Time for SpecSchedule

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

The Next method for SpecSchedule calculates the next activation time based on the schedule's specification.

```go
func (s *SpecSchedule) Next(t time.Time) time.Time
```

--------------------------------

### Job Wrapping

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Utilities for wrapping jobs with custom behavior.

```APIDOC
## JobWrapper

### DelayIfStillRunning

```go
func DelayIfStillRunning(logger Logger) JobWrapper
```

DelayIfStillRunning returns a JobWrapper that will delay the execution of a job if it is already running.

### Recover

```go
func Recover(logger Logger) JobWrapper
```

Recover returns a JobWrapper that will recover from panics and log them.

### SkipIfStillRunning

```go
func SkipIfStillRunning(logger Logger) JobWrapper
```

SkipIfStillRunning returns a JobWrapper that will skip the execution of a job if it is already running.
```

--------------------------------

### Create Logger from Printf

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Wraps a logger with a Printf method (like standard library 'log') into the cron Logger interface. This implementation only logs errors.

```go
func PrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger
```

--------------------------------

### Decorate a Job with a Chain

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

The Then method applies a chain of JobWrappers to a given job. This is useful for applying behaviors like logging or recovery to multiple jobs.

```go
func (c Chain) Then(j Job) Job
```

```go
NewChain(m1, m2, m3).Then(job)
```

--------------------------------

### Calculate Next Activation Time

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

The Next method for ConstantDelaySchedule returns the next scheduled activation time, rounded to the nearest second.

```go
func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time
```

--------------------------------

### Wrap Jobs with a Chain

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option that applies a chain of JobWrappers to all submitted jobs. This allows for consistent decoration of job behavior.

```go
WithChain(Recover(nil), SkipIfStillRunning(nil))
```

--------------------------------

### Wrapping Individual Jobs in Cron

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Apply job wrappers to individual jobs by explicitly wrapping them using cron.NewChain. This is useful for applying specific behaviors to certain jobs.

```go
job = cron.NewChain(
	cron.SkipIfStillRunning(logger),
).Then(job)

```

--------------------------------

### Recover Panics Wrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a JobWrapper that recovers from panics within a job and logs them using the provided logger.

```go
func Recover(logger Logger) JobWrapper
```

--------------------------------

### Schedule Creation

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Functions for creating different types of schedules.

```APIDOC
## ConstantDelaySchedule

### Every

```go
func Every(duration time.Duration) ConstantDelaySchedule
```

Every returns a crontab Schedule that activates once every duration. Delays of less than a second are not supported (will round up to 1 second). Any fields less than a Second are truncated.

## Schedule

### ParseStandard

```go
func ParseStandard(standardSpec string) (Schedule, error)
```

ParseStandard parses a standard cron spec string into a Schedule. 

## Parser

### NewParser

```go
func NewParser(options ParseOption) Parser
```

NewParser creates a new Parser with the given options.
```

--------------------------------

### SkipIfStillRunning

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a job wrapper that skips an invocation of the job if a previous invocation is still running. Logs skips to the given logger.

```APIDOC
## SkipIfStillRunning

### Description
Creates a job wrapper that skips an invocation of the job if a previous invocation is still running. Logs skips to the given logger.

### Signature
```go
func SkipIfStillRunning(logger Logger) JobWrapper
```

### Parameters
#### Path Parameters
- **logger** (Logger) - The logger to use for logging skipped invocations.
```

--------------------------------

### Option.WithChain

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Returns an Option that sets the JobWrapper chain for the Cron instance. This allows for decorating jobs with custom behaviors.

```APIDOC
## Option.WithChain

### Description
WithChain returns an Option that sets the JobWrapper chain for the Cron instance. This allows for decorating jobs with custom behaviors.

### Method
POST

### Endpoint
/option/chain

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **wrappers** (...JobWrapper) - Required - A variadic list of JobWrappers to include in the chain.

### Request Example
```json
{
  "wrappers": [
    "DelayIfStillRunning(myLogger)",
    "Recover(myLogger)"
  ]
}
```

### Response
#### Success Response (200)
- **option** (Option) - The Option to configure the chain.

#### Response Example
```json
{
  "option": "<option_instance>"
}
```
```

--------------------------------

### Create Verbose Logger from Printf

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Wraps a logger with a Printf method (like standard library 'log') into the cron Logger interface. This implementation logs all messages verbosely.

```go
func VerbosePrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger
```

--------------------------------

### Set Cron Parser

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option to specify a custom parser for cron schedule strings. This is useful if you need to support non-standard cron formats.

```go
WithParser(myParser)
```

--------------------------------

### Cron.New

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Creates a new Cron job runner, allowing for customization through various options such as time zone, parser, and job wrappers.

```APIDOC
## Cron.New

### Description
New returns a new Cron job runner, modified by the given options.

### Method
POST

### Endpoint
/cron

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **opts** (...Option) - Optional - Options to configure the Cron instance.
  - **WithLocation(loc *time.Location)**: Sets the time zone.
  - **WithParser(p ScheduleParser)**: Sets the schedule parser.
  - **WithChain(wrappers ...JobWrapper)**: Wraps submitted jobs.
  - **WithLogger(logger Logger)**: Sets a custom logger.
  - **WithSeconds()**: Enables second-level precision in the cron spec.

### Request Example
```json
{
  "opts": [
    "WithLocation(time.UTC)",
    "WithSeconds()"
  ]
}
```

### Response
#### Success Response (200)
- **cron** (*Cron) - A pointer to the newly created Cron instance.

#### Response Example
```json
{
  "cron": "<cron_instance_pointer>"
}
```
```

--------------------------------

### Recover

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a job wrapper that recovers from panics in wrapped jobs and logs them using the provided logger.

```APIDOC
## Recover

### Description
Creates a job wrapper that recovers from panics in wrapped jobs and logs them using the provided logger.

### Signature
```go
func Recover(logger Logger) JobWrapper
```

### Parameters
#### Path Parameters
- **logger** (Logger) - The logger to use for logging recovered panics.
```

--------------------------------

### SpecSchedule.Next

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Calculates the next activation time for a SpecSchedule based on the current time.

```APIDOC
## Next

### Description
Returns the next activation time, later than the given time. If no time can be found to satisfy the schedule, return the zero time.

### Method Signature
```go
func (s *SpecSchedule) Next(t time.Time) time.Time
```

### Parameters
* `t` (time.Time) - The reference time.

### Returns
* `time.Time` - The next activation time.
```

--------------------------------

### Create a SkipIfStillRunning Job Wrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a JobWrapper that prevents a job from running if it is already running. This is useful for preventing concurrent execution of long-running jobs.

```go
SkipIfStillRunning(logger)
```

--------------------------------

### Configure Cron with a Custom Schedule Parser

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

WithParser is an Option to specify a custom ScheduleParser for parsing cron spec strings.

```go
func WithParser(p ScheduleParser) Option
```

--------------------------------

### JobWrapper.SkipIfStillRunning

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Creates a JobWrapper that skips the execution of a job if it's already running. This ensures that only one instance of the job runs at a time.

```APIDOC
## JobWrapper.SkipIfStillRunning

### Description
SkipIfStillRunning creates a JobWrapper that skips the execution of a job if it's already running. This ensures that only one instance of the job runs at a time.

### Method
POST

### Endpoint
/jobwrapper/skip

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **logger** (Logger) - Required - A logger instance to record skipped executions.

### Request Example
```json
{
  "logger": "myLogger"
}
```

### Response
#### Success Response (200)
- **jobWrapper** (JobWrapper) - The created JobWrapper.

#### Response Example
```json
{
  "jobWrapper": "<job_wrapper_instance>"
}
```
```

--------------------------------

### Enable Seconds in Cron Specification

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option to enable the seconds field in cron specification strings. By default, cron specs only support minute, hour, day of month, month, and day of week.

```go
WithSeconds()
```

--------------------------------

### Interval Schedules in Cron

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Schedule jobs to run at fixed intervals using the @every duration format. The interval is based on when the job is added or cron is run, not accounting for job runtime.

```go
@every <duration>
```

--------------------------------

### Cron Job Interface

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Defines the interface for jobs that can be scheduled and run by the cron package.

```go
type Job interface {
	Run()
}
```

--------------------------------

### Default Cron Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

The default logger used by Cron if none is explicitly provided. It logs to standard output with a 'cron: ' prefix.

```go
var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))
```

--------------------------------

### SpecSchedule.Next

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Calculates the next activation time for a SpecSchedule, later than the given time.

```APIDOC
## SpecSchedule.Next

### Description
Calculates the next activation time for a SpecSchedule, later than the given time. If no time can be found to satisfy the schedule, it returns the zero time.

### Method Signature
```go
func (s *SpecSchedule) Next(t time.Time) time.Time
```

### Parameters
* **t** (*time.Time*) - The reference time after which to find the next activation.

### Returns
* **time.Time** - The next activation time, or the zero time if none can be found.
```

--------------------------------

### Option.WithParser

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Returns an Option that sets a custom schedule parser for the Cron instance. This allows for different cron spec formats.

```APIDOC
## Option.WithParser

### Description
WithParser returns an Option that sets a custom schedule parser for the Cron instance. This allows for different cron spec formats.

### Method
POST

### Endpoint
/option/parser

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **p** (ScheduleParser) - Required - The custom schedule parser.

### Request Example
```json
{
  "p": "myCustomParser"
}
```

### Response
#### Success Response (200)
- **option** (Option) - The Option to configure the parser.

#### Response Example
```json
{
  "option": "<option_instance>"
}
```
```

--------------------------------

### Managing Entries

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Retrieve and inspect the scheduled entries within the cron instance.

```APIDOC
## Cron

### Entries

```go
func (c *Cron) Entries() []Entry
```

Entries returns a snapshot of the cron entries.

### Entry

```go
func (c *Cron) Entry(id EntryID) Entry
```

Entry returns the entry with the given ID. 

### Remove

```go
func (c *Cron) Remove(id EntryID)
```

Remove stops the job with the given ID and removes it from the cron instance. Note that its Run() method will be descheduled, but the job instance itself is not freed.
```

--------------------------------

### Create a Logger from an Interface

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

PrintfLogger creates a Logger instance from an object that implements a Printf-like method.

```go
func PrintfLogger(l interface{ ... }) Logger
```

--------------------------------

### Option.WithLogger

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Returns an Option that sets a custom logger for the Cron instance. This logger will be used for all logging activities.

```APIDOC
## Option.WithLogger

### Description
WithLogger returns an Option that sets a custom logger for the Cron instance. This logger will be used for all logging activities.

### Method
POST

### Endpoint
/option/logger

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **logger** (Logger) - Required - The custom logger to use.

### Request Example
```json
{
  "logger": "myCustomLogger"
}
```

### Response
#### Success Response (200)
- **option** (Option) - The Option to configure the logger.

#### Response Example
```json
{
  "option": "<option_instance>"
}
```
```

--------------------------------

### Cron Option: With Location

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option that overrides the default timezone location for the cron instance.

```go
func WithLocation(loc *time.Location) Option
```

--------------------------------

### WithSeconds

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Configures the parser to include a seconds field as the first field in the schedule interpretation.

```APIDOC
## WithSeconds

### Description
Configures the parser to include a seconds field as the first field in the schedule interpretation.

### Function Signature
```go
func WithSeconds() Option
```

### Parameters
None.
```

--------------------------------

### Setting Cron Time Zone with Options

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Configure the cron scheduler to use a specific time zone, such as UTC, during its construction.

```go
cron.New(
    cron.WithLocation(time.UTC))

```

--------------------------------

### Cron Entry Structure

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Represents a scheduled job within the cron scheduler, including its ID, schedule, timing, and the job itself.

```go
type Entry struct {
	// ID is the cron-assigned ID of this entry, which may be used to look up a
	// snapshot or remove it.
	ID EntryID

	// Schedule on which this job should be run.
	Schedule Schedule

	// Next time the job will run, or the zero time if Cron has not been
	// started or this entry's schedule is unsatisfiable
	Next time.Time

	// Prev is the last time this job was run, or the zero time if never.
	Prev time.Time

	// WrappedJob is the thing to run when the Schedule is activated.
	WrappedJob Job

	// Job is the thing that was submitted to cron.
	// It is kept around so that user code that needs to get at the job later,
	e.g. via Entries() can do so.
	Job Job
}
```

--------------------------------

### Enabling Verbose Logging in Cron

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Activate verbose logging for detailed insights into cron operations, including job runs and scheduling decisions. This uses a custom logger adapter.

```go
cron.New(
	cron.WithLogger(
		cron.VerbosePrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))))

```

--------------------------------

### Set Cron Logger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option to specify a custom logger for the Cron instance. This allows for centralized logging of cron job activities.

```go
WithLogger(myLogger)
```

--------------------------------

### WithLogger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Specifies a custom logger to be used by the cron instance.

```APIDOC
## WithLogger

### Description
Specifies a custom logger to be used by the cron instance.

### Signature
```go
func WithLogger(logger Logger) Option
```

### Parameters
#### Path Parameters
- **logger** (Logger) - The logger implementation to use.
```

--------------------------------

### WithParser

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Overrides the default parser used for interpreting job schedules with a custom ScheduleParser.

```APIDOC
## WithParser

### Description
Overrides the default parser used for interpreting job schedules with a custom ScheduleParser.

### Function Signature
```go
func WithParser(p ScheduleParser) Option
```

### Parameters
* **p** (*ScheduleParser*) - The custom parser to use for schedule specifications.
```

--------------------------------

### Skip Job if Still Running Wrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a JobWrapper that skips a job invocation if a previous one is still running. Skips are logged at the Info level.

```go
func SkipIfStillRunning(logger Logger) JobWrapper
```

--------------------------------

### Option.WithSeconds

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Returns an Option that enables second-level precision in the cron spec parsing. This allows for schedules with second granularity.

```APIDOC
## Option.WithSeconds

### Description
WithSeconds returns an Option that enables second-level precision in the cron spec parsing. This allows for schedules with second granularity.

### Method
POST

### Endpoint
/option/seconds

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **option** (Option) - The Option to enable second precision.

#### Response Example
```json
{
  "option": "<option_instance>"
}
```
```

--------------------------------

### Entry.Valid

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Checks if the cron entry is valid (i.e., not the zero entry).

```APIDOC
## Entry.Valid

### Description
Checks if the cron entry is valid (i.e., not the zero entry).

### Signature
```go
func (e Entry) Valid() bool
```

### Returns
- **bool**: True if the entry is valid, false otherwise.
```

--------------------------------

### Custom Cron Parser with Seconds Field

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Construct a new Cron instance with a custom parser that includes the seconds field. This retains the old behavior of accepting an optional seconds field at the beginning of the cron spec.

```go
// Seconds field, required
cron.New(cron.WithSeconds())

// Seconds field, optional
cron.New(
    cron.WithParser(
        cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor))


```

--------------------------------

### Create a Verbose Logger from an Interface

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

VerbosePrintfLogger creates a Logger instance from an object that implements a Printf-like method, intended for more detailed logging.

```go
func VerbosePrintfLogger(l interface{ ... }) Logger
```

--------------------------------

### Option.WithLocation

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Returns an Option that sets the time zone for the Cron instance. Schedules will be interpreted according to this time zone.

```APIDOC
## Option.WithLocation

### Description
WithLocation returns an Option that sets the time zone for the Cron instance. Schedules will be interpreted according to this time zone.

### Method
POST

### Endpoint
/option/location

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **loc** (*time.Location) - Required - The time zone to set.

### Request Example
```json
{
  "loc": "time.UTC"
}
```

### Response
#### Success Response (200)
- **option** (Option) - The Option to configure the time zone.

#### Response Example
```json
{
  "option": "<option_instance>"
}
```
```

--------------------------------

### Cron Logger Interface

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Interface for logging within the cron package, supporting Info and Error messages with key-value pairs. It's a subset of github.com/go-logr/logr.

```go
type Logger interface {
	// Info logs routine messages about cron's operation.
	Info(msg string, keysAndValues ...interface{})
	// Error logs an error condition.
	Error(err error, msg string, keysAndValues ...interface{})
}
```

--------------------------------

### Predefined Schedules in Cron

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Use predefined schedules for common cron job timings. These are shortcuts for specific cron expressions.

```markdown
Entry                  | Description                                | Equivalent To
-----                  | -----------                                | -------------
@yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *
@monthly               | Run once a month, midnight, first of month | 0 0 1 * *
@weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0
@daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *
@hourly                | Run once an hour, beginning of hour        | 0 * * * *
```

--------------------------------

### JobWrapper.DelayIfStillRunning

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Creates a JobWrapper that delays the execution of a job if it's already running. This prevents concurrent runs of the same job.

```APIDOC
## JobWrapper.DelayIfStillRunning

### Description
DelayIfStillRunning creates a JobWrapper that delays the execution of a job if it's already running. This prevents concurrent runs of the same job.

### Method
POST

### Endpoint
/jobwrapper/delay

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **logger** (Logger) - Required - A logger instance to record delay events.

### Request Example
```json
{
  "logger": "myLogger"
}
```

### Response
#### Success Response (200)
- **jobWrapper** (JobWrapper) - The created JobWrapper.

#### Response Example
```json
{
  "jobWrapper": "<job_wrapper_instance>"
}
```
```

--------------------------------

### JobWrapper.Recover

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Creates a JobWrapper that recovers from panics in the job. It logs the panic and allows the scheduler to continue.

```APIDOC
## JobWrapper.Recover

### Description
Recover creates a JobWrapper that recovers from panics in the job. It logs the panic and allows the scheduler to continue.

### Method
POST

### Endpoint
/jobwrapper/recover

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **logger** (Logger) - Required - A logger instance to record panics.

### Request Example
```json
{
  "logger": "myLogger"
}
```

### Response
#### Success Response (200)
- **jobWrapper** (JobWrapper) - The created JobWrapper.

#### Response Example
```json
{
  "jobWrapper": "<job_wrapper_instance>"
}
```
```

--------------------------------

### Cron.Schedule

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Schedules a job to run at a specified schedule. The job is wrapped with the configured chain.

```APIDOC
## Cron.Schedule

### Description
Schedules a job to run at a specified schedule. The job is wrapped with the configured chain.

### Signature
```go
func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID
```

### Parameters
#### Path Parameters
- **schedule** (Schedule) - The schedule on which to run the job.
- **cmd** (Job) - The job to be scheduled.
```

--------------------------------

### Validate Cron Entry

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Checks if a cron entry is valid (i.e., not the zero value).

```go
func (e Entry) Valid() bool
```

--------------------------------

### Set Cron Time Zone

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Returns a Cron Option to set the time zone for schedule interpretation. If not specified, time.Local is used by default.

```go
WithLocation(time.UTC)
```

--------------------------------

### Delay Job if Still Running Wrapper

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Creates a JobWrapper that prevents subsequent runs of a job if a previous invocation is still running. Logs delays longer than a minute.

```go
func DelayIfStillRunning(logger Logger) JobWrapper
```

--------------------------------

### Add a Job to Cron Schedule

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

AddJob schedules a Job interface to run based on a cron spec string. It returns an EntryID for later removal.

```go
func (c *Cron) AddJob(spec string, cmd Job) (EntryID, error)
```

--------------------------------

### Parse Standard Crontab Specification

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Parses a standard crontab specification string. It requires 5 entries (minute, hour, day of month, month, day of week) and returns an error if the spec is invalid. Accepts standard specs like "* * * * ?" and descriptors like "@midnight".

```go
sched, err := ParseStandard("* * * * ?")
```

```go
sched, err := ParseStandard("@midnight")
```

--------------------------------

### Cron.Entry

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Retrieves a snapshot of a specific cron entry by its ID. Returns nil if the entry is not found.

```APIDOC
## Cron.Entry

### Description
Retrieves a snapshot of a specific cron entry by its ID. Returns nil if the entry is not found.

### Signature
```go
func (c *Cron) Entry(id EntryID) Entry
```

### Parameters
#### Path Parameters
- **id** (EntryID) - The ID of the entry to retrieve.
```

--------------------------------

### Parse a Standard Cron Specification

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Parses a standard cron specification string into a Schedule object. This is useful for creating schedules based on common cron syntax.

```go
schedule, err := ParseStandard("* * * * ? * ")
```

--------------------------------

### Parser.Parse

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Parses a cron specification string into a Schedule. Returns an error if the specification is invalid.

```APIDOC
## Parser.Parse

### Description
Parses a cron specification string into a Schedule. Returns an error if the specification is invalid. It accepts crontab specs and features configured by NewParser.

### Method Signature
```go
func (p Parser) Parse(spec string) (Schedule, error)
```

### Parameters
* **spec** (*string*) - The cron specification string to parse.

### Returns
* **Schedule** - The parsed schedule.
* **error** - An error if the spec is invalid.
```

--------------------------------

### Add a Job to Cron Schedule

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Adds a Job to be executed on a specified schedule. Similar to AddFunc, it uses the Cron instance's time zone for parsing and returns an EntryID.

```go
c.AddJob("* * * * *", job)

```

--------------------------------

### Parse a Standard Cron Specification

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

ParseStandard parses a standard cron specification string into a Schedule object.

```go
func ParseStandard(standardSpec string) (Schedule, error)
```

--------------------------------

### WithLocation

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Overrides the timezone location of the cron instance.

```APIDOC
## WithLocation

### Description
Overrides the timezone location of the cron instance.

### Signature
```go
func WithLocation(loc *time.Location) Option
```

### Parameters
#### Path Parameters
- **loc** (*time.Location) - The desired time zone location.
```

--------------------------------

### VerbosePrintfLogger

Source: https://pkg.go.dev/github.com/robfig/cron/v3

Wraps a Printf-based logger (like the standard library "log") into a Logger interface that logs all messages.

```APIDOC
## VerbosePrintfLogger

### Description
Wraps a Printf-based logger (like the standard library "log") into a Logger interface that logs all messages.

### Signature
```go
func VerbosePrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger
```

### Parameters
#### Path Parameters
- **l** (interface{ Printf(string, ...interface{}) }) - A Printf-based logger.
```

--------------------------------

### Logger.VerbosePrintfLogger

Source: https://pkg.go.dev/github.com/robfig/cron/v3%40v3.0.1

Creates a Logger that prints verbose messages using the provided Printf-style formatting function.

```APIDOC
## Logger.VerbosePrintfLogger

### Description
VerbosePrintfLogger creates a Logger that prints verbose messages using the provided Printf-style formatting function.

### Method
POST

### Endpoint
/logger/verboseprintf

### Parameters
#### Path Parameters
- None

#### Query Parameters
- **l** (interface{ ... }) - Required - The Printf-style formatting function.

### Request Example
```json
{
  "l": "fmt.Printf"
}
```

### Response
#### Success Response (200)
- **logger** (Logger) - The created Logger instance.

#### Response Example
```json
{
  "logger": "<logger_instance>"
}
```
```
Tokens:
Raw