Replace pkg/errors with fmt.Errorf

.github/workflows/ci.yml

@@ -15,25 +15,13 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v8
 
       - name: Build
         run: go build -v ./...
 
       - name: Test
         run: go test -v ./...
-
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.23'
-
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
-        with:
-          version: latest

cmd_mem.go

@@ -13,10 +13,9 @@ import (
 	"sync"
 	"text/tabwriter"
 
+	"github.com/duckdb/duckdb-go/v2"
 	"github.com/kr/logfmt"
-	"github.com/marcboeker/go-duckdb/v2"
 	"github.com/minio/simdjson-go"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 	"github.com/urfave/cli/v3"
 )
@@ -57,16 +56,16 @@ func (e *MemCountEvent) Fill(el *simdjson.Element) error {
 	var rootEl *simdjson.Element
 	rootEl, err = el.Iter.FindElement(rootEl, "@")
 	if err != nil {
-		return errors.Wrap(err, "failed to find '@' element")
+		return fmt.Errorf("failed to find '@' element: %w", err)
 	}
 	var obj *simdjson.Object
 	obj, err = rootEl.Iter.Object(obj)
 	if err != nil {
-		return errors.Wrap(err, "failed to get object from '@' element")
+		return fmt.Errorf("failed to get object from '@' element: %w", err)
 	}
 	elements, err := obj.Parse(nil)
 	if err != nil {
-		return errors.Wrap(err, "failed to parse object elements")
+		return fmt.Errorf("failed to parse object elements: %w", err)
 	}
 	for _, m := range elements.Elements {
 		var value int64
@@ -159,7 +158,7 @@ var memCountCmd = &cli.Command{
 		} else {
 			f, err := os.Open(input)
 			if err != nil {
-				return errors.Wrap(err, "open input")
+				return fmt.Errorf("open input: %w", err)
 			}
 			defer func() { _ = f.Close() }()
 			r = f
@@ -181,7 +180,7 @@ var memCountCmd = &cli.Command{
 			case "map":
 				var event MemCountEvent
 				if err := event.Fill(data); err != nil {
-					return errors.Wrap(err, "failed to fill event from map data")
+					return fmt.Errorf("failed to fill event from map data: %w", err)
 				}
 				intervalCount++
 				totalEvent.Add(&event)
@@ -227,7 +226,7 @@ var memRawEventPool = sync.Pool{
 	},
 }
 
-var ErrUnknownMemField = errors.New("unknown mem field")
+var ErrUnknownMemField = fmt.Errorf("unknown mem field")
 
 func (e *memRawEvent) HandleLogfmt(key []byte, val []byte) (err error) {
 	k := string(key)
@@ -265,7 +264,7 @@ const createMemTableSQL = `CREATE TABLE IF NOT EXISTS %s (
 	Size UBIGINT,
 	Type STRING)`
 
-const dropMemTableSQL = `DROP TABLE IF EXISTS %s`
+const dropMemTableSQL = `DROP TABLE IF EXISTS `
 
 type memAppendRowFn = func(e *memRawEvent) error
 
@@ -276,14 +275,14 @@ func memJSONParseThenAppend(r io.Reader, appendRow memAppendRowFn) error {
 		case "printf":
 			buf, err := data.Iter.StringBytes()
 			if err != nil {
-				return errors.Wrap(err, "failed to get 'printf' data as string")
+				return fmt.Errorf("failed to get 'printf' data as string: %w", err)
 			}
 			e := memRawEventPool.Get().(*memRawEvent)
 			*e = memRawEvent{}
 			err = logfmt.Unmarshal(buf, e)
 			if err != nil {
 				memRawEventPool.Put(e)
-				return errors.Wrap(err, "failed to unmarshal logfmt data")
+				return fmt.Errorf("failed to unmarshal logfmt data: %w", err)
 			}
 			err = appendRow(e)
 			memRawEventPool.Put(e)
@@ -333,7 +332,7 @@ var memRawCmd = &cli.Command{
 		db := sql.OpenDB(connector)
 		defer func() { _ = db.Close() }()
 
-		_, err = db.Exec(fmt.Sprintf(dropMemTableSQL, tableName))
+		_, err = db.Exec(dropMemTableSQL + tableName)
 		if err != nil {
 			return err
 		}
@@ -356,7 +355,7 @@ var memRawCmd = &cli.Command{
 		} else {
 			f, err := os.Open(input)
 			if err != nil {
-				return errors.Wrap(err, "open input")
+				return fmt.Errorf("open input: %w", err)
 			}
 			defer func() { _ = f.Close() }()
 			r = f

cmd_net.go

@@ -13,10 +13,9 @@ import (
 	"sync"
 	"text/tabwriter"
 
+	"github.com/duckdb/duckdb-go/v2"
 	"github.com/kr/logfmt"
-	"github.com/marcboeker/go-duckdb/v2"
 	"github.com/minio/simdjson-go"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 	"github.com/urfave/cli/v3"
 )
@@ -63,16 +62,16 @@ func (e *NetCountEvent) Fill(el *simdjson.Element) error {
 	var rootEl *simdjson.Element
 	rootEl, err = el.Iter.FindElement(rootEl, "@")
 	if err != nil {
-		return errors.Wrap(err, "failed to find '@' element")
+		return fmt.Errorf("failed to find '@' element: %w", err)
 	}
 	var obj *simdjson.Object
 	obj, err = rootEl.Iter.Object(obj)
 	if err != nil {
-		return errors.Wrap(err, "failed to get object from '@' element")
+		return fmt.Errorf("failed to get object from '@' element: %w", err)
 	}
 	elements, err := obj.Parse(nil)
 	if err != nil {
-		return errors.Wrap(err, "failed to parse object elements")
+		return fmt.Errorf("failed to parse object elements: %w", err)
 	}
 	for _, m := range elements.Elements {
 		var value int64
@@ -177,7 +176,7 @@ var netCountCmd = &cli.Command{
 		} else {
 			f, err := os.Open(input)
 			if err != nil {
-				return errors.Wrap(err, "open input")
+				return fmt.Errorf("open input: %w", err)
 			}
 			defer func() { _ = f.Close() }()
 			r = f
@@ -199,7 +198,7 @@ var netCountCmd = &cli.Command{
 			case "map":
 				var event NetCountEvent
 				if err := event.Fill(data); err != nil {
-					return errors.Wrap(err, "failed to fill event from map data")
+					return fmt.Errorf("failed to fill event from map data: %w", err)
 				}
 				intervalCount++
 				totalEvent.Add(&event)
@@ -247,7 +246,7 @@ var netRawEventPool = sync.Pool{
 	},
 }
 
-var ErrUnknownNetField = errors.New("unknown net field")
+var ErrUnknownNetField = fmt.Errorf("unknown net field")
 
 func (e *netRawEvent) HandleLogfmt(key []byte, val []byte) (err error) {
 	k := string(key)
@@ -295,7 +294,7 @@ const createNetTableSQL = `CREATE TABLE IF NOT EXISTS %s (
 	Bytes UBIGINT,
 	Protocol STRING)`
 
-const dropNetTableSQL = `DROP TABLE IF EXISTS %s`
+const dropNetTableSQL = `DROP TABLE IF EXISTS `
 
 type netAppendRowFn = func(e *netRawEvent) error
 
@@ -306,14 +305,14 @@ func netJSONParseThenAppend(r io.Reader, appendRow netAppendRowFn) error {
 		case "printf":
 			buf, err := data.Iter.StringBytes()
 			if err != nil {
-				return errors.Wrap(err, "failed to get 'printf' data as string")
+				return fmt.Errorf("failed to get 'printf' data as string: %w", err)
 			}
 			e := netRawEventPool.Get().(*netRawEvent)
 			*e = netRawEvent{}
 			err = logfmt.Unmarshal(buf, e)
 			if err != nil {
 				netRawEventPool.Put(e)
-				return errors.Wrap(err, "failed to unmarshal logfmt data")
+				return fmt.Errorf("failed to unmarshal logfmt data: %w", err)
 			}
 			err = appendRow(e)
 			netRawEventPool.Put(e)
@@ -363,7 +362,7 @@ var netRawCmd = &cli.Command{
 		db := sql.OpenDB(connector)
 		defer func() { _ = db.Close() }()
 
-		_, err = db.Exec(fmt.Sprintf(dropNetTableSQL, tableName))
+		_, err = db.Exec(dropNetTableSQL + tableName)
 		if err != nil {
 			return err
 		}
@@ -386,7 +385,7 @@ var netRawCmd = &cli.Command{
 		} else {
 			f, err := os.Open(input)
 			if err != nil {
-				return errors.Wrap(err, "open input")
+				return fmt.Errorf("open input: %w", err)
 			}
 			defer func() { _ = f.Close() }()
 			r = f

cmd_proc.go

@@ -13,10 +13,9 @@ import (
 	"sync"
 	"text/tabwriter"
 
+	"github.com/duckdb/duckdb-go/v2"
 	"github.com/kr/logfmt"
-	"github.com/marcboeker/go-duckdb/v2"
 	"github.com/minio/simdjson-go"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
 	"github.com/urfave/cli/v3"
 )
@@ -57,16 +56,16 @@ func (e *ProcCountEvent) Fill(el *simdjson.Element) error {
 	var rootEl *simdjson.Element
 	rootEl, err = el.Iter.FindElement(rootEl, "@")
 	if err != nil {
-		return errors.Wrap(err, "failed to find '@' element")
+		return fmt.Errorf("failed to find '@' element: %w", err)
 	}
 	var obj *simdjson.Object
 	obj, err = rootEl.Iter.Object(obj)
 	if err != nil {
-		return errors.Wrap(err, "failed to get object from '@' element")
+		return fmt.Errorf("failed to get object from '@' element: %w", err)
 	}
 	elements, err := obj.Parse(nil)
 	if err != nil {
-		return errors.Wrap(err, "failed to parse object elements")
+		return fmt.Errorf("failed to parse object elements: %w", err)
 	}
 	for _, m := range elements.Elements {
 		var value int64
@@ -159,7 +158,7 @@ var procCountCmd = &cli.Command{
 		} else {
 			f, err := os.Open(input)
 			if err != nil {
-				return errors.Wrap(err, "open input")
+				return fmt.Errorf("open input: %w", err)
 			}
 			defer func() { _ = f.Close() }()
 			r = f
@@ -181,7 +180,7 @@ var procCountCmd = &cli.Command{
 			case "map":
 				var event ProcCountEvent
 				if err := event.Fill(data); err != nil {
-					return errors.Wrap(err, "failed to fill event from map data")
+					return fmt.Errorf("failed to fill event from map data: %w", err)
 				}
 				intervalCount++
 				totalEvent.Add(&event)
@@ -227,7 +226,7 @@ var procRawEventPool = sync.Pool{
 	},
 }
 
-var ErrUnknownProcField = errors.New("unknown proc field")
+var ErrUnknownProcField = fmt.Errorf("unknown proc field")
 
 func (e *procRawEvent) HandleLogfmt(key []byte, val []byte) (err error) {
 	k := string(key)
@@ -265,7 +264,7 @@ const createProcTableSQL = `CREATE TABLE IF NOT EXISTS %s (
 	Cmdline STRING,
 	ExitCode BIGINT)`
 
-const dropProcTableSQL = `DROP TABLE IF EXISTS %s`
+const dropProcTableSQL = `DROP TABLE IF EXISTS `
 
 type procAppendRowFn = func(e *procRawEvent) error
 
@@ -276,14 +275,14 @@ func procJSONParseThenAppend(r io.Reader, appendRow procAppendRowFn) error {
 		case "printf":
 			buf, err := data.Iter.StringBytes()
 			if err != nil {
-				return errors.Wrap(err, "failed to get 'printf' data as string")
+				return fmt.Errorf("failed to get 'printf' data as string: %w", err)
 			}
 			e := procRawEventPool.Get().(*procRawEvent)
 			*e = procRawEvent{}
 			err = logfmt.Unmarshal(buf, e)
 			if err != nil {
 				procRawEventPool.Put(e)
-				return errors.Wrap(err, "failed to unmarshal logfmt data")
+				return fmt.Errorf("failed to unmarshal logfmt data: %w", err)
 			}
 			err = appendRow(e)
 			procRawEventPool.Put(e)
@@ -333,7 +332,7 @@ var procRawCmd = &cli.Command{
 		db := sql.OpenDB(connector)
 		defer func() { _ = db.Close() }()
 
-		_, err = db.Exec(fmt.Sprintf(dropProcTableSQL, tableName))
+		_, err = db.Exec(dropProcTableSQL + tableName)
 		if err != nil {
 			return err
 		}
@@ -356,7 +355,7 @@ var procRawCmd = &cli.Command{
 		} else {
 			f, err := os.Open(input)
 			if err != nil {
-				return errors.Wrap(err, "open input")
+				return fmt.Errorf("open input: %w", err)
 			}
 			defer func() { _ = f.Close() }()
 			r = f