Rename CLI to asynq

2025-10-03 05:12:01 +08:00 · 2020-04-12 14:37:42 -07:00
parent b14c73809e
commit 4f11e52558
16 changed files with 1 additions and 1 deletions
--- a/tools/asynq/README.md
+++ b/tools/asynq/README.md
@@ -0,0 +1,165 @@
+# Asynqmon
+
+Asynqmon is a command line tool to monitor the tasks managed by `asynq` package.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+  - [Stats](#stats)
+  - [History](#history)
+  - [Process Status](#process-status)
+  - [List](#list)
+  - [Enqueue](#enqueue)
+  - [Delete](#delete)
+  - [Kill](#kill)
+  - [Cancel](#cancel)
+- [Config File](#config-file)
+
+## Installation
+
+In order to use the tool, compile it using the following command:
+
+    go get github.com/hibiken/asynq/tools/asynqmon
+
+This will create the asynqmon executable under your `$GOPATH/bin` directory.
+
+## Quickstart
+
+The tool has a few commands to inspect the state of tasks and queues.
+
+Run `asynqmon help` to see all the available commands.
+
+Asynqmon needs to connect to a redis-server to inspect the state of queues and tasks. Use flags to specify the options to connect to the redis-server used by your application.
+
+By default, Asynqmon will try to connect to a redis server running at `localhost:6379`.
+
+### Stats
+
+Stats command gives the overview of the current state of tasks and queues. You can run it in conjunction with `watch` command to repeatedly run `stats`.
+
+Example:
+
+    watch -n 3 asynqmon stats
+
+This will run `asynqmon stats` command every 3 seconds.
+
+![Gif](/docs/assets/asynqmon_stats.gif)
+
+### History
+
+History command shows the number of processed and failed tasks from the last x days.
+
+By default, it shows the stats from the last 10 days. Use `--days` to specify the number of days.
+
+Example:
+
+    asynqmon history --days=30
+
+![Gif](/docs/assets/asynqmon_history.gif)
+
+### Process Status
+
+PS (ProcessStatus) command shows the list of running worker processes.
+
+Example:
+
+    asynqmon ps
+
+![Gif](/docs/assets/asynqmon_ps.gif)
+
+### List
+
+List command shows all tasks in the specified state in a table format
+
+Example:
+
+    asynqmon ls retry
+    asynqmon ls scheduled
+    asynqmon ls dead
+    asynqmon ls enqueued:default
+    asynqmon ls inprogress
+
+### Enqueue
+
+There are two commands to enqueue tasks.
+
+Command `enq` takes a task ID and moves the task to **Enqueued** state. You can obtain the task ID by running `ls` command.
+
+Example:
+
+    asynqmon enq d:1575732274:bnogo8gt6toe23vhef0g
+
+Command `enqall` moves all tasks to **Enqueued** state from the specified state.
+
+Example:
+
+    asynqmon enqall retry
+
+Running the above command will move all **Retry** tasks to **Enqueued** state.
+
+### Delete
+
+There are two commands for task deletion.
+
+Command `del` takes a task ID and deletes the task. You can obtain the task ID by running `ls` command.
+
+Example:
+
+    asynqmon del r:1575732274:bnogo8gt6toe23vhef0g
+
+Command `delall` deletes all tasks which are in the specified state.
+
+Example:
+
+    asynqmon delall retry
+
+Running the above command will delete all **Retry** tasks.
+
+### Kill
+
+There are two commands to kill (i.e. move to dead state) tasks.
+
+Command `kill` takes a task ID and kills the task. You can obtain the task ID by running `ls` command.
+
+Example:
+
+    asynqmon kill r:1575732274:bnogo8gt6toe23vhef0g
+
+Command `killall` kills all tasks which are in the specified state.
+
+Example:
+
+    asynqmon killall retry
+
+Running the above command will move all **Retry** tasks to **Dead** state.
+
+### Cancel
+
+Command `cancel` takes a task ID and sends a cancelation signal to the goroutine processing the specified task.  
+You can obtain the task ID by running `ls` command.
+
+The task should be in "in-progress" state.
+Handler implementation needs to be context aware in order to actually stop processing.
+
+Example:
+
+    asynqmon cancel bnogo8gt6toe23vhef0g
+
+## Config File
+
+You can use a config file to set default values for the flags.
+This is useful, for example when you have to connect to a remote redis server.
+
+By default, `asynqmon` will try to read config file located in
+`$HOME/.asynqmon.(yaml|json)`. You can specify the file location via `--config` flag.
+
+Config file example:
+
+```yaml
+uri: 127.0.0.1:6379
+db: 2
+password: mypassword
+```
+
+This will set the default values for `--uri`, `--db`, and `--password` flags.
--- a/tools/asynq/cmd/cancel.go
+++ b/tools/asynq/cmd/cancel.go
@@ -0,0 +1,53 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// cancelCmd represents the cancel command
+var cancelCmd = &cobra.Command{
+	Use:   "cancel [task id]",
+	Short: "Sends a cancelation signal to the goroutine processing the specified task",
+	Long: `Cancel (asynqmon cancel) will send a cancelation signal to the goroutine processing 
+the specified task. 
+
+The command takes one argument which specifies the task to cancel.
+The task should be in in-progress state.
+Identifier for a task should be obtained by running "asynqmon ls" command.
+
+Handler implementation needs to be context aware for cancelation signal to
+actually cancel the processing.
+
+Example: asynqmon cancel bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  cancel,
+}
+
+func init() {
+	rootCmd.AddCommand(cancelCmd)
+}
+
+func cancel(cmd *cobra.Command, args []string) {
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+
+	err := r.PublishCancelation(args[0])
+	if err != nil {
+		fmt.Printf("could not send cancelation signal: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully sent cancelation siganl for task %s\n", args[0])
+}
--- a/tools/asynq/cmd/del.go
+++ b/tools/asynq/cmd/del.go
@@ -0,0 +1,73 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// delCmd represents the del command
+var delCmd = &cobra.Command{
+	Use:   "del [task id]",
+	Short: "Deletes a task given an identifier",
+	Long: `Del (asynqmon del) will delete a task given an identifier.
+
+The command takes one argument which specifies the task to delete.
+The task should be in either scheduled, retry or dead state.
+Identifier for a task should be obtained by running "asynqmon ls" command.
+
+Example: asynqmon enq d:1575732274:bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  del,
+}
+
+func init() {
+	rootCmd.AddCommand(delCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// delCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// delCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func del(cmd *cobra.Command, args []string) {
+	id, score, qtype, err := parseQueryID(args[0])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+	switch qtype {
+	case "s":
+		err = r.DeleteScheduledTask(id, score)
+	case "r":
+		err = r.DeleteRetryTask(id, score)
+	case "d":
+		err = r.DeleteDeadTask(id, score)
+	default:
+		fmt.Println("invalid argument")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully deleted %v\n", args[0])
+}
--- a/tools/asynq/cmd/delall.go
+++ b/tools/asynq/cmd/delall.go
@@ -0,0 +1,71 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var delallValidArgs = []string{"scheduled", "retry", "dead"}
+
+// delallCmd represents the delall command
+var delallCmd = &cobra.Command{
+	Use:   "delall [state]",
+	Short: "Deletes all tasks in the specified state",
+	Long: `Delall (asynqmon delall) will delete all tasks in the specified state.
+
+The argument should be one of "scheduled", "retry", or "dead".
+
+Example: asynqmon delall dead -> Deletes all dead tasks`,
+	ValidArgs: delallValidArgs,
+	Args:      cobra.ExactValidArgs(1),
+	Run:       delall,
+}
+
+func init() {
+	rootCmd.AddCommand(delallCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// delallCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// delallCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func delall(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	var err error
+	switch args[0] {
+	case "scheduled":
+		err = r.DeleteAllScheduledTasks()
+	case "retry":
+		err = r.DeleteAllRetryTasks()
+	case "dead":
+		err = r.DeleteAllDeadTasks()
+	default:
+		fmt.Printf("error: `asynqmon delall [state]` only accepts %v as the argument.\n", delallValidArgs)
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Deleted all tasks in %q state\n", args[0])
+}
--- a/tools/asynq/cmd/enq.go
+++ b/tools/asynq/cmd/enq.go
@@ -0,0 +1,76 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// enqCmd represents the enq command
+var enqCmd = &cobra.Command{
+	Use:   "enq [task id]",
+	Short: "Enqueues a task given an identifier",
+	Long: `Enq (asynqmon enq) will enqueue a task given an identifier.
+
+The command takes one argument which specifies the task to enqueue.
+The task should be in either scheduled, retry or dead state.
+Identifier for a task should be obtained by running "asynqmon ls" command.
+
+The task enqueued by this command will be processed as soon as the task 
+gets dequeued by a processor.
+
+Example: asynqmon enq d:1575732274:bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  enq,
+}
+
+func init() {
+	rootCmd.AddCommand(enqCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// enqCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// enqCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func enq(cmd *cobra.Command, args []string) {
+	id, score, qtype, err := parseQueryID(args[0])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+	switch qtype {
+	case "s":
+		err = r.EnqueueScheduledTask(id, score)
+	case "r":
+		err = r.EnqueueRetryTask(id, score)
+	case "d":
+		err = r.EnqueueDeadTask(id, score)
+	default:
+		fmt.Println("invalid argument")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully enqueued %v\n", args[0])
+}
--- a/tools/asynq/cmd/enqall.go
+++ b/tools/asynq/cmd/enqall.go
@@ -0,0 +1,75 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var enqallValidArgs = []string{"scheduled", "retry", "dead"}
+
+// enqallCmd represents the enqall command
+var enqallCmd = &cobra.Command{
+	Use:   "enqall [state]",
+	Short: "Enqueues all tasks in the specified state",
+	Long: `Enqall (asynqmon enqall) will enqueue all tasks in the specified state.
+
+The argument should be one of "scheduled", "retry", or "dead".
+
+The tasks enqueued by this command will be processed as soon as it
+gets dequeued by a processor.
+
+Example: asynqmon enqall dead -> Enqueues all dead tasks`,
+	ValidArgs: enqallValidArgs,
+	Args:      cobra.ExactValidArgs(1),
+	Run:       enqall,
+}
+
+func init() {
+	rootCmd.AddCommand(enqallCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// enqallCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// enqallCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func enqall(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	var n int64
+	var err error
+	switch args[0] {
+	case "scheduled":
+		n, err = r.EnqueueAllScheduledTasks()
+	case "retry":
+		n, err = r.EnqueueAllRetryTasks()
+	case "dead":
+		n, err = r.EnqueueAllDeadTasks()
+	default:
+		fmt.Printf("error: `asynqmon enqall [state]` only accepts %v as the argument.\n", enqallValidArgs)
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Enqueued %d tasks in %q state\n", n, args[0])
+}
--- a/tools/asynq/cmd/history.go
+++ b/tools/asynq/cmd/history.go
@@ -0,0 +1,71 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var days int
+
+// historyCmd represents the history command
+var historyCmd = &cobra.Command{
+	Use:   "history",
+	Short: "Shows historical aggregate data",
+	Long: `History (asynqmon history) will show the number of processed and failed tasks
+from the last x days.
+
+By default, it will show the data from the last 10 days.
+
+Example: asynqmon history -x=30 -> Shows stats from the last 30 days`,
+	Args: cobra.NoArgs,
+	Run:  history,
+}
+
+func init() {
+	rootCmd.AddCommand(historyCmd)
+	historyCmd.Flags().IntVarP(&days, "days", "x", 10, "show data from last x days")
+}
+
+func history(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+
+	stats, err := r.HistoricalStats(days)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	printDailyStats(stats)
+}
+
+func printDailyStats(stats []*rdb.DailyStats) {
+	format := strings.Repeat("%v\t", 4) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	fmt.Fprintf(tw, format, "Date (UTC)", "Processed", "Failed", "Error Rate")
+	fmt.Fprintf(tw, format, "----------", "---------", "------", "----------")
+	for _, s := range stats {
+		var errrate string
+		if s.Processed == 0 {
+			errrate = "N/A"
+		} else {
+			errrate = fmt.Sprintf("%.2f%%", float64(s.Failed)/float64(s.Processed)*100)
+		}
+		fmt.Fprintf(tw, format, s.Time.Format("2006-01-02"), s.Processed, s.Failed, errrate)
+	}
+	tw.Flush()
+}
--- a/tools/asynq/cmd/kill.go
+++ b/tools/asynq/cmd/kill.go
@@ -0,0 +1,72 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// killCmd represents the kill command
+var killCmd = &cobra.Command{
+	Use:   "kill [task id]",
+	Short: "Kills a task given an identifier",
+	Long: `Kill (asynqmon kill) will put a task in dead state given an identifier.
+
+The command takes one argument which specifies the task to kill.
+The task should be in either scheduled or retry state.
+Identifier for a task should be obtained by running "asynqmon ls" command.
+
+Example: asynqmon kill r:1575732274:bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  kill,
+}
+
+func init() {
+	rootCmd.AddCommand(killCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// killCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// killCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func kill(cmd *cobra.Command, args []string) {
+	id, score, qtype, err := parseQueryID(args[0])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+	switch qtype {
+	case "s":
+		err = r.KillScheduledTask(id, score)
+	case "r":
+		err = r.KillRetryTask(id, score)
+	default:
+		fmt.Println("invalid argument")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully killed %v\n", args[0])
+
+}
--- a/tools/asynq/cmd/killall.go
+++ b/tools/asynq/cmd/killall.go
@@ -0,0 +1,70 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var killallValidArgs = []string{"scheduled", "retry"}
+
+// killallCmd represents the killall command
+var killallCmd = &cobra.Command{
+	Use:   "killall [state]",
+	Short: "Kills all tasks in the specified state",
+	Long: `Killall (asynqmon killall) will update all tasks from the specified state to dead state.
+
+The argument should be either "scheduled" or "retry".
+
+Example: asynqmon killall retry -> Update all retry tasks to dead tasks`,
+	ValidArgs: killallValidArgs,
+	Args:      cobra.ExactValidArgs(1),
+	Run:       killall,
+}
+
+func init() {
+	rootCmd.AddCommand(killallCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// killallCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// killallCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func killall(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	var n int64
+	var err error
+	switch args[0] {
+	case "scheduled":
+		n, err = r.KillAllScheduledTasks()
+	case "retry":
+		n, err = r.KillAllRetryTasks()
+	default:
+		fmt.Printf("error: `asynqmon killall [state]` only accepts %v as the argument.\n", killallValidArgs)
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully updated %d tasks to \"dead\" state\n", n)
+}
--- a/tools/asynq/cmd/ls.go
+++ b/tools/asynq/cmd/ls.go
@@ -0,0 +1,229 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/rs/xid"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var lsValidArgs = []string{"enqueued", "inprogress", "scheduled", "retry", "dead"}
+
+// lsCmd represents the ls command
+var lsCmd = &cobra.Command{
+	Use:   "ls [state]",
+	Short: "Lists tasks in the specified state",
+	Long: `Ls (asynqmon ls) will list all tasks in the specified state in a table format.
+
+The command takes one argument which specifies the state of tasks.
+The argument value should be one of "enqueued", "inprogress", "scheduled",
+"retry", or "dead".
+
+Example:
+asynqmon ls dead -> Lists all tasks in dead state
+
+Enqueued tasks requires a queue name after ":"
+Example:
+asynqmon ls enqueued:default  -> List tasks from default queue
+asynqmon ls enqueued:critical -> List tasks from critical queue 
+`,
+	Args: cobra.ExactValidArgs(1),
+	Run:  ls,
+}
+
+// Flags
+var pageSize int
+var pageNum int
+
+func init() {
+	rootCmd.AddCommand(lsCmd)
+	lsCmd.Flags().IntVar(&pageSize, "size", 30, "page size")
+	lsCmd.Flags().IntVar(&pageNum, "page", 0, "page number - zero indexed (default 0)")
+}
+
+func ls(cmd *cobra.Command, args []string) {
+	if pageSize < 0 {
+		fmt.Println("page size cannot be negative.")
+		os.Exit(1)
+	}
+	if pageNum < 0 {
+		fmt.Println("page number cannot be negative.")
+		os.Exit(1)
+	}
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	parts := strings.Split(args[0], ":")
+	switch parts[0] {
+	case "enqueued":
+		if len(parts) != 2 {
+			fmt.Printf("error: Missing queue name\n`asynqmon ls enqueued:[queue name]`\n")
+			os.Exit(1)
+		}
+		listEnqueued(r, parts[1])
+	case "inprogress":
+		listInProgress(r)
+	case "scheduled":
+		listScheduled(r)
+	case "retry":
+		listRetry(r)
+	case "dead":
+		listDead(r)
+	default:
+		fmt.Printf("error: `asynqmon ls [state]`\nonly accepts %v as the argument.\n", lsValidArgs)
+		os.Exit(1)
+	}
+}
+
+// queryID returns an identifier used for "enq" command.
+// score is the zset score and queryType should be one
+// of "s", "r" or "d" (scheduled, retry, dead respectively).
+func queryID(id xid.ID, score int64, qtype string) string {
+	const format = "%v:%v:%v"
+	return fmt.Sprintf(format, qtype, score, id)
+}
+
+// parseQueryID is a reverse operation of queryID function.
+// It takes a queryID and return each part of id with proper
+// type if valid, otherwise it reports an error.
+func parseQueryID(queryID string) (id xid.ID, score int64, qtype string, err error) {
+	parts := strings.Split(queryID, ":")
+	if len(parts) != 3 {
+		return xid.NilID(), 0, "", fmt.Errorf("invalid id")
+	}
+	id, err = xid.FromString(parts[2])
+	if err != nil {
+		return xid.NilID(), 0, "", fmt.Errorf("invalid id")
+	}
+	score, err = strconv.ParseInt(parts[1], 10, 64)
+	if err != nil {
+		return xid.NilID(), 0, "", fmt.Errorf("invalid id")
+	}
+	qtype = parts[0]
+	if len(qtype) != 1 || !strings.Contains("srd", qtype) {
+		return xid.NilID(), 0, "", fmt.Errorf("invalid id")
+	}
+	return id, score, qtype, nil
+}
+
+func listEnqueued(r *rdb.RDB, qname string) {
+	tasks, err := r.ListEnqueued(qname, rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Printf("No enqueued tasks in %q queue\n", qname)
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			fmt.Fprintf(w, tmpl, t.ID, t.Type, t.Payload, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listInProgress(r *rdb.RDB) {
+	tasks, err := r.ListInProgress(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No in-progress tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			fmt.Fprintf(w, tmpl, t.ID, t.Type, t.Payload)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listScheduled(r *rdb.RDB) {
+	tasks, err := r.ListScheduled(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No scheduled tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Process In", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			processIn := fmt.Sprintf("%.0f seconds", t.ProcessAt.Sub(time.Now()).Seconds())
+			fmt.Fprintf(w, tmpl, queryID(t.ID, t.Score, "s"), t.Type, t.Payload, processIn, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listRetry(r *rdb.RDB) {
+	tasks, err := r.ListRetry(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No retry tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Next Retry", "Last Error", "Retried", "Max Retry", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			var nextRetry string
+			if d := t.ProcessAt.Sub(time.Now()); d > 0 {
+				nextRetry = fmt.Sprintf("in %v", d.Round(time.Second))
+			} else {
+				nextRetry = "right now"
+			}
+			fmt.Fprintf(w, tmpl, queryID(t.ID, t.Score, "r"), t.Type, t.Payload, nextRetry, t.ErrorMsg, t.Retried, t.Retry, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listDead(r *rdb.RDB) {
+	tasks, err := r.ListDead(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No dead tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Last Failed", "Last Error", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			fmt.Fprintf(w, tmpl, queryID(t.ID, t.Score, "d"), t.Type, t.Payload, t.LastFailedAt, t.ErrorMsg, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
--- a/tools/asynq/cmd/ps.go
+++ b/tools/asynq/cmd/ps.go
@@ -0,0 +1,118 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// psCmd represents the ps command
+var psCmd = &cobra.Command{
+	Use:   "ps",
+	Short: "Shows all background worker processes",
+	Long: `Ps (asynqmon ps) will show all background worker processes
+backed by the specified redis instance.
+
+The command shows the following for each process:
+* Host and PID of the process
+* Number of active workers out of worker pool
+* Queue configuration
+* State of the worker process ("running" | "stopped")
+* Time the process was started
+
+A "running" process is processing tasks in queues.
+A "stopped" process is no longer processing new tasks.`,
+	Args: cobra.NoArgs,
+	Run:  ps,
+}
+
+func init() {
+	rootCmd.AddCommand(psCmd)
+}
+
+func ps(cmd *cobra.Command, args []string) {
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+
+	processes, err := r.ListProcesses()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(processes) == 0 {
+		fmt.Println("No processes")
+		return
+	}
+
+	// sort by hostname and pid
+	sort.Slice(processes, func(i, j int) bool {
+		x, y := processes[i], processes[j]
+		if x.Host != y.Host {
+			return x.Host < y.Host
+		}
+		return x.PID < y.PID
+	})
+
+	// print processes
+	cols := []string{"Host", "PID", "State", "Active Workers", "Queues", "Started"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, ps := range processes {
+			fmt.Fprintf(w, tmpl,
+				ps.Host, ps.PID, ps.Status,
+				fmt.Sprintf("%d/%d", ps.ActiveWorkerCount, ps.Concurrency),
+				formatQueues(ps.Queues), timeAgo(ps.Started))
+		}
+	}
+	printTable(cols, printRows)
+}
+
+// timeAgo takes a time and returns a string of the format "<duration> ago".
+func timeAgo(since time.Time) string {
+	d := time.Since(since).Round(time.Second)
+	return fmt.Sprintf("%v ago", d)
+}
+
+func formatQueues(qmap map[string]int) string {
+	// sort queues by priority and name
+	type queue struct {
+		name     string
+		priority int
+	}
+	var queues []*queue
+	for qname, p := range qmap {
+		queues = append(queues, &queue{qname, p})
+	}
+	sort.Slice(queues, func(i, j int) bool {
+		x, y := queues[i], queues[j]
+		if x.priority != y.priority {
+			return x.priority > y.priority
+		}
+		return x.name < y.name
+	})
+
+	var b strings.Builder
+	l := len(queues)
+	for _, q := range queues {
+		fmt.Fprintf(&b, "%s:%d", q.name, q.priority)
+		l--
+		if l > 0 {
+			b.WriteString(" ")
+		}
+	}
+	return b.String()
+}
--- a/tools/asynq/cmd/rmq.go
+++ b/tools/asynq/cmd/rmq.go
@@ -0,0 +1,54 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// rmqCmd represents the rmq command
+var rmqCmd = &cobra.Command{
+	Use:   "rmq [queue name]",
+	Short: "Removes the specified queue",
+	Long: `Rmq (asynqmon rmq) will remove the specified queue.
+By default, it will remove the queue only if it's empty.
+Use --force option to override this behavior.
+
+Example: asynqmon rmq low -> Removes "low" queue`,
+	Args: cobra.ExactValidArgs(1),
+	Run:  rmq,
+}
+
+var rmqForce bool
+
+func init() {
+	rootCmd.AddCommand(rmqCmd)
+	rmqCmd.Flags().BoolVarP(&rmqForce, "force", "f", false, "remove the queue regardless of its size")
+}
+
+func rmq(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	err := r.RemoveQueue(args[0], rmqForce)
+	if err != nil {
+		if _, ok := err.(*rdb.ErrQueueNotEmpty); ok {
+			fmt.Printf("error: %v\nIf you are sure you want to delete it, run 'asynqmon rmq --force %s'\n", err, args[0])
+			os.Exit(1)
+		}
+		fmt.Printf("error: %v", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully removed queue %q\n", args[0])
+}
--- a/tools/asynq/cmd/root.go
+++ b/tools/asynq/cmd/root.go
@@ -0,0 +1,112 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+
+	homedir "github.com/mitchellh/go-homedir"
+	"github.com/spf13/viper"
+)
+
+var cfgFile string
+
+// Flags
+var uri string
+var db int
+var password string
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "asynqmon",
+	Short: "A monitoring tool for asynq queues",
+	Long:  `Asynqmon is a montoring CLI to inspect tasks and queues managed by asynq.`,
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	cobra.OnInitialize(initConfig)
+
+	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file to set flag defaut values (default is $HOME/.asynqmon.yaml)")
+	rootCmd.PersistentFlags().StringVarP(&uri, "uri", "u", "127.0.0.1:6379", "redis server URI")
+	rootCmd.PersistentFlags().IntVarP(&db, "db", "n", 0, "redis database number (default is 0)")
+	rootCmd.PersistentFlags().StringVarP(&password, "password", "p", "", "password to use when connecting to redis server")
+	viper.BindPFlag("uri", rootCmd.PersistentFlags().Lookup("uri"))
+	viper.BindPFlag("db", rootCmd.PersistentFlags().Lookup("db"))
+	viper.BindPFlag("password", rootCmd.PersistentFlags().Lookup("password"))
+}
+
+// initConfig reads in config file and ENV variables if set.
+func initConfig() {
+	if cfgFile != "" {
+		// Use config file from the flag.
+		viper.SetConfigFile(cfgFile)
+	} else {
+		// Find home directory.
+		home, err := homedir.Dir()
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+
+		// Search config in home directory with name ".asynqmon" (without extension).
+		viper.AddConfigPath(home)
+		viper.SetConfigName(".asynqmon")
+	}
+
+	viper.AutomaticEnv() // read in environment variables that match
+
+	// If a config file is found, read it in.
+	if err := viper.ReadInConfig(); err == nil {
+		fmt.Println("Using config file:", viper.ConfigFileUsed())
+	}
+}
+
+// printTable is a helper function to print data in table format.
+//
+// cols is a list of headers and printRow specifies how to print rows.
+//
+// Example:
+// type User struct {
+//     Name string
+//     Addr string
+//     Age  int
+// }
+// data := []*User{{"user1", "addr1", 24}, {"user2", "addr2", 42}, ...}
+// cols := []string{"Name", "Addr", "Age"}
+// printRows := func(w io.Writer, tmpl string) {
+//     for _, u := range data {
+//         fmt.Fprintf(w, tmpl, u.Name, u.Addr, u.Age)
+//     }
+// }
+// printTable(cols, printRows)
+func printTable(cols []string, printRows func(w io.Writer, tmpl string)) {
+	format := strings.Repeat("%v\t", len(cols)) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	var headers []interface{}
+	var seps []interface{}
+	for _, name := range cols {
+		headers = append(headers, name)
+		seps = append(seps, strings.Repeat("-", len(name)))
+	}
+	fmt.Fprintf(tw, format, headers...)
+	fmt.Fprintf(tw, format, seps...)
+	printRows(tw, format)
+	tw.Flush()
+}
--- a/tools/asynq/cmd/stats.go
+++ b/tools/asynq/cmd/stats.go
@@ -0,0 +1,153 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// statsCmd represents the stats command
+var statsCmd = &cobra.Command{
+	Use:   "stats",
+	Short: "Shows current state of the tasks and queues",
+	Long: `Stats (aysnqmon stats) will show the overview of tasks and queues at that instant.
+
+Specifically, the command shows the following:
+* Number of tasks in each state
+* Number of tasks in each queue
+* Aggregate data for the current day
+* Basic information about the running redis instance
+
+To monitor the tasks continuously, it's recommended that you run this
+command in conjunction with the watch command.
+
+Example: watch -n 3 asynqmon stats -> Shows current state of tasks every three seconds`,
+	Args: cobra.NoArgs,
+	Run:  stats,
+}
+
+func init() {
+	rootCmd.AddCommand(statsCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// statsCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// statsCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func stats(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+
+	stats, err := r.CurrentStats()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	info, err := r.RedisInfo()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Println("STATES")
+	printStates(stats)
+	fmt.Println()
+
+	fmt.Println("QUEUES")
+	printQueues(stats.Queues)
+	fmt.Println()
+
+	fmt.Printf("STATS FOR %s UTC\n", stats.Timestamp.UTC().Format("2006-01-02"))
+	printStats(stats)
+	fmt.Println()
+
+	fmt.Println("REDIS INFO")
+	printInfo(info)
+	fmt.Println()
+}
+
+func printStates(s *rdb.Stats) {
+	format := strings.Repeat("%v\t", 5) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	fmt.Fprintf(tw, format, "InProgress", "Enqueued", "Scheduled", "Retry", "Dead")
+	fmt.Fprintf(tw, format, "----------", "--------", "---------", "-----", "----")
+	fmt.Fprintf(tw, format, s.InProgress, s.Enqueued, s.Scheduled, s.Retry, s.Dead)
+	tw.Flush()
+}
+
+func printQueues(queues map[string]int) {
+	var qnames, seps, counts []string
+	for q := range queues {
+		qnames = append(qnames, strings.Title(q))
+	}
+	sort.Strings(qnames) // sort for stable order
+	for _, q := range qnames {
+		seps = append(seps, strings.Repeat("-", len(q)))
+		counts = append(counts, strconv.Itoa(queues[strings.ToLower(q)]))
+	}
+	format := strings.Repeat("%v\t", len(qnames)) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	fmt.Fprintf(tw, format, toInterfaceSlice(qnames)...)
+	fmt.Fprintf(tw, format, toInterfaceSlice(seps)...)
+	fmt.Fprintf(tw, format, toInterfaceSlice(counts)...)
+	tw.Flush()
+}
+
+func printStats(s *rdb.Stats) {
+	format := strings.Repeat("%v\t", 3) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	fmt.Fprintf(tw, format, "Processed", "Failed", "Error Rate")
+	fmt.Fprintf(tw, format, "---------", "------", "----------")
+	var errrate string
+	if s.Processed == 0 {
+		errrate = "N/A"
+	} else {
+		errrate = fmt.Sprintf("%.2f%%", float64(s.Failed)/float64(s.Processed)*100)
+	}
+	fmt.Fprintf(tw, format, s.Processed, s.Failed, errrate)
+	tw.Flush()
+}
+
+func printInfo(info map[string]string) {
+	format := strings.Repeat("%v\t", 5) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	fmt.Fprintf(tw, format, "Version", "Uptime", "Connections", "Memory Usage", "Peak Memory Usage")
+	fmt.Fprintf(tw, format, "-------", "------", "-----------", "------------", "-----------------")
+	fmt.Fprintf(tw, format,
+		info["redis_version"],
+		fmt.Sprintf("%s days", info["uptime_in_days"]),
+		info["connected_clients"],
+		fmt.Sprintf("%sB", info["used_memory_human"]),
+		fmt.Sprintf("%sB", info["used_memory_peak_human"]),
+	)
+	tw.Flush()
+}
+
+func toInterfaceSlice(strs []string) []interface{} {
+	var res []interface{}
+	for _, s := range strs {
+		res = append(res, s)
+	}
+	return res
+}
--- a/tools/asynq/cmd/workers.go
+++ b/tools/asynq/cmd/workers.go
@@ -0,0 +1,75 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sort"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// workersCmd represents the workers command
+var workersCmd = &cobra.Command{
+	Use:   "workers",
+	Short: "Shows all running workers information",
+	Long: `Workers (asynqmon workers) will show all running workers information.
+
+The command shows the following for each worker:
+* Process in which the worker is running
+* ID of the task worker is processing
+* Type of the task worker is processing
+* Payload of the task worker is processing
+* Queue that the task was pulled from.
+* Time the worker started processing the task`,
+	Args: cobra.NoArgs,
+	Run:  workers,
+}
+
+func init() {
+	rootCmd.AddCommand(workersCmd)
+}
+
+func workers(cmd *cobra.Command, args []string) {
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+
+	workers, err := r.ListWorkers()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	if len(workers) == 0 {
+		fmt.Println("No workers")
+		return
+	}
+
+	// sort by started timestamp or ID.
+	sort.Slice(workers, func(i, j int) bool {
+		x, y := workers[i], workers[j]
+		if x.Started != y.Started {
+			return x.Started.Before(y.Started)
+		}
+		return x.ID.String() < y.ID.String()
+	})
+
+	cols := []string{"Process", "ID", "Type", "Payload", "Queue", "Started"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, wk := range workers {
+			fmt.Fprintf(w, tmpl,
+				fmt.Sprintf("%s:%d", wk.Host, wk.PID), wk.ID, wk.Type, wk.Payload, wk.Queue, timeAgo(wk.Started))
+		}
+	}
+	printTable(cols, printRows)
+}
--- a/tools/asynq/main.go
+++ b/tools/asynq/main.go
@@ -0,0 +1,11 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package main
+
+import "github.com/hibiken/asynq/tools/asynq/cmd"
+
+func main() {
+	cmd.Execute()
+}