Update all the things #42

This is mostly just a routine update of nixpkgs and go modules. Except, for the rollbar-go module, which is an update to what should have been a new major version as a bunch of backwards incompatible changes were released. The new rollbar code plays better with stack trace containing errors and even has support github.com/pkg/errors in the module, which replaces much of what is in internal/rollbar, 🎉!

Author: mmlb

.drone.yml

@@ -1,35 +1,34 @@
 ---
-
 workspace:
   base: /go
   path: src/github.com/packethost/pkg
 
 pipeline:
   fmt:
     group: ci
-    image: golang:1.13-alpine
+    image: golang:1.17-alpine
     commands:
       - apk add --update --upgrade --no-cache git
       - go get golang.org/x/tools/cmd/goimports
       - goimports -d . | (! grep .)
 
   lint:
     group: ci
-    image: golangci/golangci-lint:v1.23.8
+    image: golangci/golangci-lint:v1.42
     commands:
       - golangci-lint run -v -D errcheck
 
   test:
     group: ci
-    image: golang:1.13
+    image: golang:1.17
     commands:
-      - GO111MODULE=on go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+      - go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
 
   build:
     group: ci
-    image: golang:1.13-alpine
+    image: golang:1.17-alpine
     commands:
-      - GO111MODULE=on CGO_ENABLED=0 go build ./cmd/...
+      - CGO_ENABLED=0 go build ./cmd/...
 
   examplelog:
     group: examples

cmd/examplelog/main.go

@@ -28,6 +28,8 @@ func main() {
 	ll.With("error", err).Info("just an info level message about an error")
 	ll.Error(err, "this is an actual error! Will even go to rollbar where we can ignore it or not")
 
+	ll.Error(errors.WithMessage(err, "error with an extra WithMessage"))
+
 	helpfulWrapper(ll, "this is being called via helpfulWrapper")
 	l.Close()
 }

go.mod

@@ -3,22 +3,25 @@ module github.com/packethost/pkg
 go 1.12
 
 require (
-	github.com/gogo/protobuf v1.2.1 // indirect
-	github.com/grpc-ecosystem/go-grpc-middleware v1.0.0
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
-	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/pkg/errors v0.9.1
-	github.com/prometheus/client_golang v1.0.0
-	github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4
-	github.com/prometheus/common v0.6.0 // indirect
-	github.com/prometheus/procfs v0.0.3 // indirect
-	github.com/rollbar/rollbar-go v1.0.2
-	github.com/sirupsen/logrus v1.4.2 // indirect
+	github.com/prometheus/client_golang v1.11.0
+	github.com/prometheus/client_model v0.2.0
+	github.com/prometheus/common v0.31.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/rollbar/rollbar-go v1.4.2
+	github.com/rollbar/rollbar-go/errors v0.0.0-20210929193720-32947096267e
 	github.com/stretchr/testify v1.7.0
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.22.0
-	go.uber.org/multierr v1.6.0 // indirect
-	go.uber.org/zap v1.16.0
-	golang.org/x/text v0.3.2 // indirect
-	google.golang.org/grpc v1.39.0
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.25.0
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.7.0 // indirect
+	go.uber.org/zap v1.19.1
+	golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f // indirect
+	golang.org/x/sys v0.0.0-20211015200801-69063c4bb744 // indirect
+	golang.org/x/text v0.3.7 // indirect
+	google.golang.org/genproto v0.0.0-20211018162055-cf77aa76bad2 // indirect
+	google.golang.org/grpc v1.41.0
 	google.golang.org/grpc/examples v0.0.0-20210728214646-ad0a2a847cdf
 )

go.sum

@@ -4,13 +4,11 @@
 package rollbar
 
 import (
-	"fmt"
 	"os"
-	"runtime"
 
 	"github.com/packethost/pkg/env"
-	"github.com/pkg/errors"
 	rollbar "github.com/rollbar/rollbar-go"
+	rollbarerrors "github.com/rollbar/rollbar-go/errors"
 	"go.uber.org/zap"
 )
 
@@ -37,96 +35,13 @@ func Setup(l *zap.SugaredLogger, service string) func() {
 		enable = false
 	}
 	rollbar.SetEnabled(enable)
+	rollbar.SetStackTracer(rollbarerrors.StackTracer)
 
 	return rollbar.Wait
 }
 
-// rError exists to implement rollbar.CauseStacker so that rollbar can have stack info.
-// see https://github.com/rollbar/rollbar-go/blob/v1.0.2/doc.go#L64
-type rError struct {
-	err error
-}
-
-func (e rError) Error() string {
-	return e.err.Error()
-}
-
-func (e rError) Cause() error {
-	return e.err
-}
-
-// logInternalError is a helper to log errors through zap and to rollbar if we run into an error while logging a client's error.
-// We can use rollbar.ErrorWithExtras here because the stack trace rollbar collects will be of where error is.
-// This handles the so called "error while logging error" case.
-func logInternalError(err error, ctx map[string]interface{}) {
-	l := log.With("error", err)
-	if len(ctx) != 0 {
-		fields := make([]interface{}, 0, len(ctx)*2)
-		for k, v := range ctx {
-			fields = append(fields, k)
-			fields = append(fields, v)
-		}
-		l = l.With(fields...)
-	}
-	ctx["errorVerbose"] = fmt.Sprintf("%+v", err)
-	l.Error(err)
-	// 1 level of stack frames are skipped, because we don't want care to have logInternalError show up
-	rollbar.ErrorWithStackSkipWithExtras(rollbar.ERR, err, 1, ctx)
-}
-
-// Stack converts a github.com/pkg/errors Error stack into a rollbar stack
-func (e rError) Stack() rollbar.Stack {
-	type stackTracer interface {
-		StackTrace() errors.StackTrace
-	}
-	type causer interface {
-		Cause() error
-	}
-	ctx := map[string]interface{}{}
-
-	err := e.Cause()
-	var st stackTracer
-	var ok bool
-	// try to find if there's a stackTracer in the stack of errors
-	// WithMessage does not add a stack so New->WithMessage->WM->...->WM means we need to unwrap until we get to the
-	// New'd one.
-	for {
-		st, ok = err.(stackTracer)
-		if ok {
-			break
-		}
-		cause, ok := err.(causer)
-		if !ok {
-			ctx["cause"] = e.Cause()
-			logInternalError(errors.New("cause does not implement StackTracer"), ctx)
-			return nil
-		}
-		err = cause.Cause()
-	}
-
-	stack := st.StackTrace()
-	rStack := rollbar.Stack(make([]rollbar.Frame, len(stack)))
-
-	for i, frame := range stack {
-		// From pkg/error's docs
-		//
-		// Frame represents a program counter inside a stack frame.
-		// For historical reasons if Frame is interpreted as a uintptr
-		// its value represents the program counter + 1.
-		// type Frame uintptr
-		frame -= 1
-
-		f := runtime.FuncForPC(uintptr(frame))
-		rStack[i].Method = f.Name()
-		rStack[i].Filename, rStack[i].Line = f.FileLine(uintptr(frame))
-	}
-
-	return rStack
-}
-
-func Notify(err error, args ...interface{}) {
-	rErr := rError{err: err}
-	rollbar.Error(rErr)
+func Notify(err error) {
+	rollbar.Error(err)
 }
 
 func getEnvironment() string {

log/internal/rollbar/rollbar.go

@@ -9,9 +9,7 @@ import (
 	"testing"
 
 	"github.com/pkg/errors"
-	rollbar "github.com/rollbar/rollbar-go"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zaptest"
+	rollbarerr "github.com/rollbar/rollbar-go/errors"
 )
 
 func TestStack(t *testing.T) {
@@ -20,9 +18,9 @@ func TestStack(t *testing.T) {
 	err := errors.New("hi")
 	n := runtime.Callers(1, pc)
 
-	stack := []rollbar.Frame(rError{err: err}.Stack())
-	if n == 0 {
-		t.Fatal("unable to recover stack information")
+	stack, ok := rollbarerr.StackTracer(err)
+	if !ok {
+		t.Fatalf("rollbarerr.StackTracer returned false")
 	}
 	pc = pc[:n]
 	frames := runtime.CallersFrames(pc)
@@ -41,12 +39,12 @@ func TestStack(t *testing.T) {
 		}
 
 		t.Logf("want: method=%v %v:%v", want.Function, want.File, want.Line)
-		t.Logf(" got: method=%v %v:%v", got.Method, got.Filename, got.Line)
-		if want.File != got.Filename {
-			t.Fatalf("filename mismatch: i=%d\nwant=%s\n got=%s\n", i, want.File, got.Filename)
+		t.Logf(" got: method=%v %v:%v", got.Function, got.File, got.Line)
+		if want.File != got.File {
+			t.Fatalf("filename mismatch: i=%d\nwant=%s\n got=%s\n", i, want.File, got.File)
 		}
-		if want.Func.Name() != got.Method {
-			t.Fatalf("func name mismatch: i=%d\nwant=%s\n got=%s\n", i, want.Func.Name(), got.Method)
+		if want.Func.Name() != got.Function {
+			t.Fatalf("func name mismatch: i=%d\nwant=%s\n got=%s\n", i, want.Func.Name(), got.Function)
 		}
 		if want.Line != got.Line {
 			t.Fatalf("line number mismatch: i=%d\nwant=%d\n got=%d\n", i, want.Line, got.Line)
@@ -63,36 +61,23 @@ func TestStack(t *testing.T) {
 	}
 }
 
-func TestError(t *testing.T) {
-	err := errors.New("hi")
-	rErr := rError{err: err}
-	if rErr.Error() != err.Error() {
-		t.Fatalf("Error() mismatch:\nwant=%s\n got=%s\n", err.Error(), rErr.Error())
-	}
-}
-
-func TestCause(t *testing.T) {
-	err := errors.New("hi")
-	rErr := rError{err: err}
-	if rErr.Cause() != err {
-		t.Fatalf("Cause() mismatch:\nwant=%v\n got=%v\n", err, rErr.Cause())
-	}
-}
-
 func TestPkgErrorsCompat(t *testing.T) {
-	log = zaptest.NewLogger(t, zaptest.Level(zap.WarnLevel)).Sugar()
-	for _, err := range []error{
-		errors.Errorf("Errorf"),
-		errors.New("New"),
-		errors.WithMessage(errors.New("New"), "WithMessage errors.New"),
-		errors.WithStack(fmt.Errorf("fmt.Errorf")),
-		errors.WithStack(errors.New("New")),
-		errors.Wrap(fmt.Errorf("fmt.Errorf"), "Wrap fmt.Errrof"),
-		errors.Wrap(errors.New("New"), "Wrap errors.New"),
+	for name, err := range map[string]error{
+		"Errorf":                errors.Errorf("Errorf"),
+		"New":                   errors.New("New"),
+		"WithStack(fmt.Errorf)": errors.WithStack(fmt.Errorf("fmt.Errorf")),
+		"WithStack(errors.New)": errors.WithStack(errors.New("New")),
+		"Wrap(fmt.Errorf)":      errors.Wrap(fmt.Errorf("fmt.Errorf"), "Wrap fmt.Errrof"),
+		"Wrap(errors.New)":      errors.Wrap(errors.New("New"), "Wrap errors.New"),
 	} {
-		rErr := rError{err: err}
-		if rErr.Stack() == nil {
-			t.Fatalf("expected err to implement stackTracer but does not: %v", err)
-		}
+		t.Run(name, func(t *testing.T) {
+			stack, ok := rollbarerr.StackTracer(err)
+			if !ok {
+				t.Fatal("rollbarerr.StackTracer returned false")
+			}
+			if stack == nil {
+				t.Fatalf("expected err to implement rollbar.StackTracer but does not: %v", err)
+			}
+		})
 	}
 }

log/internal/rollbar/rollbar_test.go

@@ -100,14 +100,14 @@ func (l Logger) Close() {
 }
 
 // Error is used to log an error, the error will be forwared to rollbar and/or other external services.
-// All the values of arg are stringified and concatenated without any strings.
+// All the values of arg are stringified and concatenated without any space.
 // If no args are provided err.Error() is used as the log message.
 func (l Logger) Error(err error, args ...interface{}) {
 	if err == nil {
 		return
 	}
 	if ok := os.Getenv("ROLLBAR_TOKEN"); ok != "" {
-		rollbar.Notify(err, args)
+		rollbar.Notify(err)
 	}
 	if len(args) == 0 {
 		args = append(args, err)

log/log.go

@@ -58,15 +58,15 @@ func TestNewDatabaseCollectorWithNoLabels(t *testing.T) {
 	collector := NewDatabaseCollector(db)
 
 	if collector == nil {
-		t.Error("got nil collector want DatabaseCollector")
+		t.Fatal("got nil collector want DatabaseCollector")
 	}
 
 	if collector.db != db {
-		t.Errorf("got %+v database want %+v", collector.db, db)
+		t.Fatalf("got %+v database want %+v", collector.db, db)
 	}
 
 	if collector.labels != nil {
-		t.Errorf("got %q labels want nil", collector.labels)
+		t.Fatalf("got %q labels want nil", collector.labels)
 	}
 }
 
@@ -77,15 +77,15 @@ func TestNewDatabaseCollectorWithLabels(t *testing.T) {
 	collector := NewDatabaseCollectorWithLabels(db, labels)
 
 	if collector == nil {
-		t.Error("got nil collector want DatabaseCollector")
+		t.Fatal("got nil collector want DatabaseCollector")
 	}
 
 	if collector.db != db {
-		t.Errorf("got %+v database want %+v", collector.db, db)
+		t.Fatalf("got %+v database want %+v", collector.db, db)
 	}
 
 	if !labelsMatch(collector.labels, labels) {
-		t.Errorf("got %q labels want %q", collector.labels, labels)
+		t.Fatalf("got %q labels want %q", collector.labels, labels)
 	}
 }
 

prometheus/promdb/promdb_test.go

@@ -1,18 +1,12 @@
 let _pkgs = import <nixpkgs> { };
 in { pkgs ? import (_pkgs.fetchFromGitHub {
   owner = "NixOS";
-  repo = "nixpkgs-channels";
-  #branch@date: nixpkgs-unstable@2020-02-01
-  rev = "e3a9318b6fdb2b022c0bda66d399e1e481b24b5c";
-  sha256 = "1hlblna9j0afvcm20p15f5is7cmwl96mc4vavc99ydc4yc9df62a";
+  repo = "nixpkgs";
+  #branch@date: nixpkgs-unstable@2021-10-11
+  rev = "2cdd608fab0af07647da29634627a42852a8c97f";
+  sha256 = "1szv364xr25yqlljrlclv8z2lm2n1qva56ad9vd02zcmn2pimdih";
 }) { } }:
 
 with pkgs;
 
-mkShell {
-  buildInputs = [
-    go
-    goimports
-    golangci-lint
-  ];
-}
+mkShell { buildInputs = [ go goimports golangci-lint nixfmt ]; }