enviar

enviar

enviar ("to send" in Spanish) is a lightweight Go wrapper around github.com/LarnTechKe/work that provides a clean, type-safe interface for enqueuing and processing Redis-backed background jobs.

Features

• Simple enqueuing — JSON payload marshaling handled automatically.
• Delayed jobs — schedule jobs to run after a duration.
• Retry options — per-job retry with exponential, linear, or fixed backoff.
• Unique jobs — deduplicate identical payloads.
• Worker pool — built-in middleware for logging and panic recovery.
• Cron schedules — register recurring jobs with cron expressions.
• Environment-based config — zero-config defaults with env var overrides.

Installation

go get github.com/LarnTechKe/enviar

Requires Go 1.24+ and a running Redis instance.

Quick Start

Define a Job

package jobs

import "github.com/LarnTechKe/enviar"

type SendEmailJob struct{}

func (j SendEmailJob) Name() string { return "send_email" }

func (j SendEmailJob) Options() []enviar.JobOption {
    return []enviar.JobOption{
        enviar.WithMaxFails(3),
        enviar.WithMaxConcurrency(5),
    }
}

Implement a Handler

package handlers

import (
    "context"
    "encoding/json"

    "myapp/jobs"
)

type EmailHandler struct{}

func (h *EmailHandler) Job() enviar.Job { return jobs.SendEmailJob{} }

func (h *EmailHandler) PerformJob(ctx context.Context, body string) error {
    var req EmailRequest
    if err := json.Unmarshal([]byte(body), &req); err != nil {
        return err
    }
    // ... send the email ...
    return nil
}

Enqueue a Job

cfg := enviar.LoadEnv()
pool := cfg.NewPool()
defer pool.Close()

enqueuer := enviar.NewEnqueuer(pool, cfg.Namespace)

id, err := enqueuer.EnqueueBody("send_email", map[string]string{
    "to":      "[email protected]",
    "subject": "Welcome!",
    "body":    "Thanks for signing up.",
})

Enqueue with Delay

id, err := enqueuer.EnqueueBodyIn("generate_report", 30*time.Second, reportRequest)

Enqueue with Retry Options

import "github.com/LarnTechKe/work"

id, err := enqueuer.EnqueueBodyWithRetry("webhook_delivery", payload, work.RetryOptions{
    MaxRetries: 5,
    Strategy:   work.BackoffExponential,
})

Enqueue Unique Job

id, err := enqueuer.EnqueueBodyUnique("process_payment", paymentRequest)
// id == "" when a duplicate is already enqueued

Start Workers

cfg := enviar.LoadEnv()
pool := cfg.NewPool()
defer pool.Close()

wp := enviar.NewWorkerPool(pool, cfg.Namespace, cfg.Concurrency)
wp.AddJobHandlers(
    &handlers.EmailHandler{},
    &handlers.PaymentHandler{},
)

// Optional: recurring jobs
wp.AddRecurringJobs(map[string]string{
    "*/20 * * * *": "generate_report",
})

// Blocks until SIGINT/SIGTERM
wp.Start(context.Background())

Configuration

enviar reads from environment variables with sensible defaults:

Job Options

Architecture

enviar
├── config.go        — Config, LoadEnv, NewPool
├── enqueuer.go      — Enqueuer (JSON-aware job producer)
├── job.go           — Job, JobHandler interfaces; JobOption helpers
└── worker_pool.go   — WorkerPool (consumer with middleware)

enviar wraps the low-level work.Enqueuer and work.WorkerPool types, adding JSON payload marshaling, structured logging, panic recovery, and a functional-options pattern for job configuration.

License

MIT — same as the upstream work library.