v0.18.1

CHANGELOG.md

@@ -7,7 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.18.2] - 2021-06-29
+## [0.18.1] - 2020-07-04
+
+### Changed
+
+- Changed to execute task recovering logic when server starts up; Previously it needed to wait for a minute for task recovering logic to exeucte.
+
+### Fixed
+
+- Fixed task recovering logic to execute every minute
+
+## [0.18.0] - 2021-06-29
 
 ### Changed
 

README.md

@@ -26,7 +26,6 @@ Task queues are used as a mechanism to distribute work across multiple machines.
 
 - Guaranteed [at least one execution](https://www.cloudcomputingpatterns.org/at_least_once_delivery/) of a task
 - Scheduling of tasks
-- Durability since tasks are written to Redis
 - [Retries](https://github.com/hibiken/asynq/wiki/Task-Retry) of failed tasks
 - Automatic recovery of tasks in the event of a worker crash
 - [Weighted priority queues](https://github.com/hibiken/asynq/wiki/Priority-Queues#weighted-priority-queues)
@@ -58,7 +57,7 @@ Initialize your project by creating a folder and then running `go mod init githu
 go get -u github.com/hibiken/asynq
 ```
 
-Make sure you're running a Redis server locally or from a [Docker](https://hub.docker.com/_/redis) container. Version `3.0` or higher is required.
+Make sure you're running a Redis server locally or from a [Docker](https://hub.docker.com/_/redis) container. Version `4.0` or higher is required.
 
 Next, write a package that encapsulates task creation and task handling.
 
@@ -120,7 +119,7 @@ func HandleEmailDeliveryTask(ctx context.Context, t *asynq.Task) error {
     if err := json.Unmarshal(t.Payload(), &p); err != nil {
         return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
     }
-    log.Printf("Sending Email to User: user_id = %d, template_id = %s\n", p.UserID, p.TemplateID)
+    log.Printf("Sending Email to User: user_id=%d, template_id=%s", p.UserID, p.TemplateID)
     // Email delivery code ...
     return nil
 }
@@ -135,7 +134,7 @@ func (p *ImageProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error {
     if err := json.Unmarshal(t.Payload(), &p); err != nil {
         return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
     }
-    log.Printf("Resizing image: src = %s\n", p.SourceURL)
+    log.Printf("Resizing image: src=%s", p.SourceURL)
     // Image resizing code ...
     return nil
 }
@@ -145,13 +144,12 @@ func NewImageProcessor() *ImageProcessor {
 }
 ```
 
-In your application code, import the above package and use [`Client`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Client) to put tasks on the queue.
+In your application code, import the above package and use [`Client`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Client) to put tasks on queues.
 
 ```go
 package main
 
 import (
-    "fmt"
     "log"
     "time"
 
@@ -178,7 +176,7 @@ func main() {
     if err != nil {
         log.Fatalf("could not enqueue task: %v", err)
     }
-    fmt.Printf("enqueued task: id=%s queue=%s\n", info.ID, info.Queue)
+    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
 
 
     // ------------------------------------------------------------
@@ -190,7 +188,7 @@ func main() {
     if err != nil {
         log.Fatalf("could not schedule task: %v", err)
     }
-    fmt.Printf("enqueued task: id=%s queue=%s\n", info.ID, info.Queue)
+    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
 
 
     // ----------------------------------------------------------------------------
@@ -208,7 +206,7 @@ func main() {
     if err != nil {
         log.Fatalf("could not enqueue task: %v", err)
     }
-    fmt.Printf("enqueued task: id=%s queue=%s\n", info.ID, info.Queue)
+    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
 
     // ---------------------------------------------------------------------------
     // Example 4: Pass options to tune task processing behavior at enqueue time.
@@ -219,7 +217,7 @@ func main() {
     if err != nil {
         log.Fatal("could not enqueue task: %v", err)
     }
-    fmt.Printf("enqueued task: id=%s queue=%s\n", info.ID, info.Queue)
+    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
 }
 ```
 

internal/base/base.go

@@ -22,7 +22,7 @@ import (
 )
 
 // Version of asynq library and CLI.
-const Version = "0.18.0"
+const Version = "0.18.1"
 
 // DefaultQueueName is the queue name used if none are specified by user.
 const DefaultQueueName = "default"

recoverer.go

@@ -57,6 +57,7 @@ func (r *recoverer) start(wg *sync.WaitGroup) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
+		r.recover()
 		timer := time.NewTimer(r.interval)
 		for {
 			select {
@@ -65,27 +66,31 @@ func (r *recoverer) start(wg *sync.WaitGroup) {
 				timer.Stop()
 				return
 			case <-timer.C:
-				// Get all tasks which have expired 30 seconds ago or earlier.
-				deadline := time.Now().Add(-30 * time.Second)
-				msgs, err := r.broker.ListDeadlineExceeded(deadline, r.queues...)
-				if err != nil {
-					r.logger.Warn("recoverer: could not list deadline exceeded tasks")
-					continue
-				}
-				const errMsg = "deadline exceeded" // TODO: better error message
-				for _, msg := range msgs {
-					if msg.Retried >= msg.Retry {
-						r.archive(msg, errMsg)
-					} else {
-						r.retry(msg, errMsg)
-					}
-				}
-
+				r.recover()
+				timer.Reset(r.interval)
 			}
 		}
 	}()
 }
 
+func (r *recoverer) recover() {
+	// Get all tasks which have expired 30 seconds ago or earlier.
+	deadline := time.Now().Add(-30 * time.Second)
+	msgs, err := r.broker.ListDeadlineExceeded(deadline, r.queues...)
+	if err != nil {
+		r.logger.Warn("recoverer: could not list deadline exceeded tasks")
+		return
+	}
+	const errMsg = "deadline exceeded"
+	for _, msg := range msgs {
+		if msg.Retried >= msg.Retry {
+			r.archive(msg, errMsg)
+		} else {
+			r.retry(msg, errMsg)
+		}
+	}
+}
+
 func (r *recoverer) retry(msg *base.TaskMessage, errMsg string) {
 	delay := r.retryDelayFunc(msg.Retried, fmt.Errorf(errMsg), NewTask(msg.Type, msg.Payload))
 	retryAt := time.Now().Add(delay)