Modernize code

Author: openhands-agent

.circleci/config.yml

@@ -9,15 +9,15 @@ workflows:
 jobs:
   build-and-test:
     docker:
-      - image: cimg/go:1.21.5
+      - image: cimg/go:1.24.2
     steps:
       - checkout
       - run: go vet ./...
       - run: go test ./...
   govulncheck:
     docker:
-      - image: cimg/go:1.21.5
+      - image: cimg/go:1.24.2
     steps:
       - checkout
       - run: go install golang.org/x/vuln/cmd/govulncheck@latest
-      - run: govulncheck ./...
+      - run: $(go env GOPATH)/bin/govulncheck ./...

client/client.go

@@ -3,7 +3,7 @@
 // Recommended Usage:
 //
 //	type MyClient struct {
-//		Client *client.Client
+//	        Client *client.Client
 //	}
 //
 //	type ThingInput struct {
@@ -13,10 +13,10 @@
 //	}
 //
 //	func(c MyClient) Thing(input *ThingInput) (*ThingOutput, err) {
-//		var output ThingOutput
-//		req := c.Client.NewRequest("GET", "/thing", input, output)
-//		err := req.Send()
-//		return output, err
+//	        var output ThingOutput
+//	        req := c.Client.NewRequest("GET", "/thing", input, output)
+//	        err := req.Send()
+//	        return output, err
 //	}
 package client
 
@@ -109,8 +109,7 @@ func New(info metadata.ClientInfo, options ...ClientOpt) *Client {
 // A request.Request will be initialized with the http.Request, Handlers,
 // params and data.
 func (c *Client) NewRequest(ctx context.Context, method, path string, params interface{}, data interface{}) *request.Request {
-	httpReq, _ := http.NewRequest(method, path, nil)
-	httpReq = httpReq.WithContext(ctx)
+	httpReq, _ := http.NewRequestWithContext(ctx, method, path, nil)
 	httpReq.URL, _ = url.Parse(c.Info.Endpoint + path)
 
 	r := request.New(httpReq, c.Info, c.Handlers.Copy(), params, data)

client/request/handlers.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
@@ -138,7 +137,7 @@ func handleSendError(r *Request, err error) {
 			r.HTTPResponse = &http.Response{
 				StatusCode: int(code),
 				Status:     http.StatusText(int(code)),
-				Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
+				Body:       io.NopCloser(bytes.NewReader([]byte{})),
 			}
 			return
 		}
@@ -150,7 +149,7 @@ func handleSendError(r *Request, err error) {
 		r.HTTPResponse = &http.Response{
 			StatusCode: int(0),
 			Status:     http.StatusText(int(0)),
-			Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
+			Body:       io.NopCloser(bytes.NewReader([]byte{})),
 		}
 	}
 
@@ -173,7 +172,7 @@ var JSONBuilder = Handler{
 				return
 			}
 			r.HTTPRequest.ContentLength = int64(len(raw))
-			r.HTTPRequest.Body = ioutil.NopCloser(bytes.NewReader(raw))
+			r.HTTPRequest.Body = io.NopCloser(bytes.NewReader(raw))
 		}
 	},
 }
@@ -189,7 +188,7 @@ var JSONDecoder = Handler{
 			defer func() {
 				// Read the entire body, including any trailing garbage, so
 				// this connection is in a good state for reuse.
-				io.Copy(ioutil.Discard, r.HTTPResponse.Body)
+				io.Copy(io.Discard, r.HTTPResponse.Body)
 				r.HTTPResponse.Body.Close()
 			}()
 		}

counting/probabilistic_counter.go

@@ -4,8 +4,8 @@ import (
 	"hash/fnv"
 	"math"
 
-	"github.com/pkg/errors"
 	"github.com/bits-and-blooms/bitset"
+	"github.com/pkg/errors"
 )
 
 // ProbabilisticCounter implements an a linear-time counting algorithm, also known as "linear counting".
@@ -20,7 +20,7 @@ import (
 // the number of "0" entries). It then estimates the column cardinality by dividing this count by the bit map size m
 // (thus obtaining the fraction of empty bit map entries V_n) and plugging the result into the following equation:
 //
-//   n^ = -m * ln V_n (The symbol ^ denotes an estimator)"
+//	n^ = -m * ln V_n (The symbol ^ denotes an estimator)"
 //
 // Therefore, ProbabilisticCounter is able to compute an approximate distinct count for a sufficiently large number of
 // string values, with an error rate of less than 1.25% on average. It does so while using a very low amount of memory,

example/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"time"
 
@@ -101,7 +101,7 @@ func (e *Error) Error() string {
 
 // ip returns your ip.
 func ip(ctx context.Context) (string, error) {
-	req, err := http.NewRequest("GET", "http://api.ipify.org?format=text", nil)
+	req, err := http.NewRequestWithContext(ctx, "GET", "http://api.ipify.org?format=text", nil)
 	if err != nil {
 		return "", err
 	}
@@ -115,7 +115,7 @@ func ip(ctx context.Context) (string, error) {
 	resp := val.(*http.Response)
 	defer resp.Body.Close()
 
-	raw, err := ioutil.ReadAll(resp.Body)
+	raw, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return "", err
 	}

go.mod

@@ -1,6 +1,6 @@
 module github.com/remind101/pkg
 
-go 1.24.0
+go 1.24.2
 
 require (
 	cloud.google.com/go/profiler v0.4.2

go1.24.2.linux-arm64.tar.gz

@@ -3,17 +3,25 @@ package httpx
 import (
 	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"net/http"
 
-	"github.com/pkg/errors"
 	"github.com/remind101/pkg/reporter"
 )
 
+// Error reports an error and encodes it to the http.ResponseWriter
 func Error(ctx context.Context, err error, rw http.ResponseWriter, r *http.Request) {
 	reporter.Report(ctx, err)
 	EncodeError(err, rw)
 }
 
+// ErrorWithStatus reports an error with a specific status code
+func ErrorWithStatus(ctx context.Context, err error, status int, rw http.ResponseWriter, r *http.Request) {
+	reporter.Report(ctx, err)
+	EncodeErrorWithStatus(err, status, rw)
+}
+
 type temporaryError interface {
 	Temporary() bool // Is the error temporary?
 }
@@ -26,9 +34,15 @@ type statusCoder interface {
 	StatusCode() int
 }
 
+// EncodeError encodes an error to the http.ResponseWriter
 func EncodeError(err error, rw http.ResponseWriter) {
+	EncodeErrorWithStatus(err, ErrorStatusCode(err), rw)
+}
+
+// EncodeErrorWithStatus encodes an error with a specific status code
+func EncodeErrorWithStatus(err error, status int, rw http.ResponseWriter) {
 	rw.Header().Set("Content-Type", "application/json")
-	rw.WriteHeader(ErrorStatusCode(err))
+	rw.WriteHeader(status)
 
 	errorResp := map[string]string{
 		"error": err.Error(),
@@ -37,18 +51,71 @@ func EncodeError(err error, rw http.ResponseWriter) {
 	json.NewEncoder(rw).Encode(errorResp)
 }
 
+// ErrorStatusCode returns an appropriate HTTP status code based on the error type
 func ErrorStatusCode(err error) int {
-	rootErr := errors.Cause(err)
-	if e, ok := rootErr.(statusCoder); ok {
-		return e.StatusCode()
+	var sc statusCoder
+	if errors.As(err, &sc) {
+		return sc.StatusCode()
 	}
-	if e, ok := rootErr.(temporaryError); ok && e.Temporary() {
+
+	var te temporaryError
+	if errors.As(err, &te) && te.Temporary() {
 		return http.StatusServiceUnavailable
 	}
 
-	if e, ok := rootErr.(timeoutError); ok && e.Timeout() {
+	var to timeoutError
+	if errors.As(err, &to) && to.Timeout() {
 		return http.StatusServiceUnavailable
 	}
 
 	return http.StatusInternalServerError
 }
+
+// NewError creates a new error with a message and optional key-value pairs
+func NewError(msg string, keyvals ...interface{}) error {
+	return &httpError{
+		msg:     msg,
+		keyvals: keyvals,
+	}
+}
+
+// httpError is a structured error type that can include key-value pairs
+type httpError struct {
+	msg     string
+	keyvals []interface{}
+	status  int
+	err     error
+}
+
+// Error implements the error interface
+func (e *httpError) Error() string {
+	if e.err != nil {
+		return fmt.Sprintf("%s: %s", e.msg, e.err.Error())
+	}
+	return e.msg
+}
+
+// WithStatus sets the HTTP status code for the error
+func (e *httpError) WithStatus(status int) *httpError {
+	e.status = status
+	return e
+}
+
+// WithError wraps another error
+func (e *httpError) WithError(err error) *httpError {
+	e.err = err
+	return e
+}
+
+// StatusCode implements the statusCoder interface
+func (e *httpError) StatusCode() int {
+	if e.status != 0 {
+		return e.status
+	}
+	return http.StatusInternalServerError
+}
+
+// Unwrap implements the errors.Wrapper interface for Go 1.13+ error unwrapping
+func (e *httpError) Unwrap() error {
+	return e.err
+}