vgarvardt/gue has 316 GitHub stars and 27 forks. GitHot measured 0 stars in 24 hours. Last checked 2026-11-19 12:59 UTC. Last push 2026-11-14.
Crecimiento de estrellas medido
- in 24h
- 0
- in 7 days
- Recopilando historial
- in 15 days
- Recopilando historial
- in 1 month
- Recopilando historial
Cambios netos en períodos que se solapan, no totales diarios. Los datos no disponibles se dejan en blanco. Las estrellas indican interés, no calidad.
Acerca de
Golang queue on top of PostgreSQL
DatosREADME.md
Originalgue
Gue is Go queue on top of PostgreSQL that uses transaction-level locks.
Originally this project used to be a fork of bgentry/que-go but because of some backward-compatibility breaking changes and original library author not being very responsive for PRs I turned fork into standalone project. Version 2 breaks internal backward-compatibility with the original project - DB table and all the internal logic (queries, algorithms) is completely rewritten.
The name Gue is yet another silly word transformation: Queue -> Que, Go + Que -> Gue.
Install
go get -u github.com/vgarvardt/gue/v6
Additionally, you need to apply DB migration.
Usage Example
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/stdlib"
"golang.org/x/sync/errgroup"
"github.com/vgarvardt/gue/v6"
)
const (
printerQueue = "name_printer"
jobTypePrinter = "PrintName"
)
type printNameArgs struct {
Name string
}
func main() {
printName := func(ctx context.Context, j *gue.Job) error {
var args printNameArgs
if err := json.Unmarshal(j.Args, &args); err != nil {
return err
}
fmt.Printf("Hello %s!\n", args.Name)
return nil
}
pgxCfg, err := pgxpool.ParseConfig(os.Getenv("DATABASE_URL"))
if err != nil {
log.Fatal(err)
}
pgxPool, err := pgxpool.NewWithConfig(context.Background(), pgxCfg)
if err != nil {
log.Fatal(err)
}
defer pgxPool.Close()
db := stdlib.OpenDBFromPool(pgxPool)
gc, err := gue.NewClient(db)
if err != nil {
log.Fatal(err)
}
wm := gue.WorkMap{
jobTypePrinter: printName,
}
finishedJobsLog := func(ctx context.Context, j *gue.Job, err error) {
if err != nil {
return
}
j.Tx().Exec(
ctx,
"INSERT INTO finished_jobs_log (queue, type, run_at) VALUES ($1, $2, now())",
j.Queue,
j.Type,
)
}
// create a pool w/ 2 workers
workers, err := gue.NewWorkerPool(gc, wm, 2, gue.WithPoolQueue(printerQueue), gue.WithPoolHooksJobDone(finishedJobsLog))
if err != nil {
log.Fatal(err)
}
ctx, shutdown := context.WithCancel(context.Background())
// work jobs in goroutine
g, gctx := errgroup.WithContext(ctx)
g.Go(func() error {
err := workers.Run(gctx)
if err != nil {
// In a real-world applications, use a better way to shut down
// application on unrecoverable error. E.g. fx.Shutdowner from
// go.uber.org/fx module.
log.Fatal(err)
}
return err
})
args, err := json.Marshal(printNameArgs{Name: "vgarvardt"})
if err != nil {
log.Fatal(err)
}
j := &gue.Job{
Type: jobTypePrinter,
Queue: printerQueue,
Args: args,
}
if err := gc.Enqueue(context.Background(), j); err != nil {
log.Fatal(err)
}
j = &gue.Job{
Type: jobTypePrinter,
Queue: printerQueue,
RunAt: time.Now().UTC().Add(30 * time.Second), // delay 30 seconds
Args: args,
}
if err := gc.Enqueue(context.Background(), j); err != nil {
log.Fatal(err)
}
time.Sleep(30 * time.Second) // wait for while
// send shutdown signal to worker
shutdown()
if err := g.Wait(); err != nil {
log.Fatal(err)
}
}
PostgreSQL drivers
Package is using stdlib database/sql types internally and is tested with the following drivers:
pgx/v5
package main
import (
"log"
"os"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/stdlib"
"github.com/vgarvardt/gue/v6"
)
func main() {
pgxCfg, err := pgxpool.ParseConfig(os.Getenv("DATABASE_URL"))
if err != nil {
log.Fatal(err)
}
pgxPool, err := pgxpool.NewConfig(context.Background(), pgxCfg)
if err != nil {
log.Fatal(err)
}
defer pgxPool.Close()
db := stdlib.OpenDBFromPool(pgxPool)
gc, err := gue.NewClient(db)
...
}
lib/pq
package main
import (
"database/sql"
"log"
"os"
_ "github.com/lib/pq" // register postgres driver
"github.com/vgarvardt/gue/v6"
)
func main() {
db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
if err != nil {
log.Fatal(err)
}
defer db.Close()
gc, err := gue.NewClient(db)
...
}
Logging
Package is using stdlib log/slog logger internally. You can use existing adapters like go.uber.org/zap/exp/zapslog
to wrap a logger used by your application or implement your own.