Add Read and Write counters. Fix lint. Update build/test.

Author: davidnewhall

.gitignore

@@ -1,20 +1,10 @@
+# Simple go lint and test.
+os: linux
+dist: bionic
 language: go
-sudo: false
-
 go:
-  - "1.11"
-  - "1.12"
-  - "1.13"
-  - "master"
-
-matrix:
-  allow_failures:
-    - go: master
-
+  - 1.17.x
 install:
-  - go install
-  - go get -u golang.org/x/lint/golint
-
+  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go env GOPATH)/bin v1.43.0
 script:
-  - go test -v ./...
-  - diff <(golint *.go) <(printf "")
+  - make test

.travis.yml

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2015 Artem Andreenko <mio@volmy.com>
+Copyright (c) 2022 Go Lift <code@golift.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +20,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

LICENSE

@@ -0,0 +1,15 @@
+all:
+	@echo "try: make test"
+
+test: lint
+	go test -race -covermode=atomic ./...
+	# Test 32 bit OSes.
+	GOOS=linux GOARCH=386 go build .
+	GOOS=freebsd GOARCH=386 go build .
+
+lint:
+	# Test lint on four platforms.
+	GOOS=linux golangci-lint run --enable-all -D maligned,scopelint,interfacer,golint
+	GOOS=darwin golangci-lint run --enable-all -D maligned,scopelint,interfacer,golint
+	GOOS=windows golangci-lint run --enable-all -D maligned,scopelint,interfacer,golint
+	GOOS=freebsd golangci-lint run --enable-all -D maligned,scopelint,interfacer,golint

Makefile

@@ -2,13 +2,22 @@
 
 Golang counters for readers/writers.
 
-[![Build Status](https://travis-ci.org/miolini/datacounter.svg)](https://travis-ci.org/miolini/datacounter) [![GoDoc](https://godoc.org/github.com/miolini/datacounter?status.svg)](http://godoc.org/github.com/miolini/datacounter)
+[![Build Status](https://travis-ci.org/golift/datacounter.svg)](https://travis-ci.org/golift/datacounter)
+
+[GoDoc](http://godoc.org/github.com/golift/datacounter)
+
+## Fork?
+
+This fork adds `.Read()` and `.Write()` method counters in addition to the existing byte counters.
 
 ## Examples
 
 ### ReaderCounter
 
 ```go
+
+import "golift.io/datacounter"
+
 buf := bytes.Buffer{}
 buf.Write(data)
 counter := datacounter.NewReaderCounter(&buf)
@@ -22,6 +31,8 @@ if counter.Count() != dataLen {
 ### WriterCounter
 
 ```go
+import "golift.io/datacounter"
+
 buf := bytes.Buffer{}
 counter := datacounter.NewWriterCounter(&buf)
 
@@ -34,6 +45,8 @@ if counter.Count() != dataLen {
 ### http.ResponseWriter Counter
 
 ```go
+import "golift.io/datacounter"
+
 handler := func(w http.ResponseWriter, r *http.Request) {
 	w.Write(data)
 }

README.md

@@ -1,3 +1,3 @@
-module github.com/miolini/datacounter
+module golift.io/datacounter
 
-go 1.11
+go 1.17

go.mod

@@ -5,26 +5,37 @@ import (
 	"sync/atomic"
 )
 
-// ReaderCounter is counter for io.Reader
+// ReaderCounter is counter for io.Reader.
 type ReaderCounter struct {
 	io.Reader
 	count uint64
+	reads uint64
 }
 
-// NewReaderCounter function for create new ReaderCounter
+// NewReaderCounter function for create new ReaderCounter.
 func NewReaderCounter(r io.Reader) *ReaderCounter {
 	return &ReaderCounter{
 		Reader: r,
+		count:  0,
+		reads:  0,
 	}
 }
 
+// Reads counts bytes read and increments read counter.
 func (counter *ReaderCounter) Read(buf []byte) (int, error) {
 	n, err := counter.Reader.Read(buf)
 	atomic.AddUint64(&counter.count, uint64(n))
-	return n, err
+	atomic.AddUint64(&counter.reads, 1)
+
+	return n, err //nolint:wrapcheck
 }
 
-// Count function return counted bytes
+// Count function returns count of bytes read.
 func (counter *ReaderCounter) Count() uint64 {
 	return atomic.LoadUint64(&counter.count)
 }
+
+// Reads function returns count of calls to Read() method.
+func (counter *ReaderCounter) Reads() uint64 {
+	return atomic.LoadUint64(&counter.reads)
+}

reader.go

@@ -1,21 +1,32 @@
-package datacounter
+package datacounter_test
 
 import (
 	"bytes"
 	"io"
 	"io/ioutil"
 	"testing"
-)
 
-var data = []byte("Hello, World!")
-var dataLen = uint64(len(data))
+	"golift.io/datacounter"
+)
 
 func TestReaderCounter(t *testing.T) {
+	t.Parallel()
+
+	var (
+		data    = []byte("Hello, World!")
+		dataLen = uint64(len(data))
+	)
+
 	buf := bytes.Buffer{}
-	buf.Write(data)
-	counter := NewReaderCounter(&buf)
-	io.Copy(ioutil.Discard, counter)
+	_, _ = buf.Write(data)
+	counter := datacounter.NewReaderCounter(&buf)
+	_, _ = io.Copy(ioutil.Discard, counter)
+
 	if counter.Count() != dataLen {
 		t.Fatalf("count mismatch len of test data: %d != %d", counter.Count(), len(data))
 	}
+
+	if counter.Reads() != 2 {
+		t.Fatalf("reads mismatch len of test data: %d != 1", counter.Reads())
+	}
 }

reader_test.go

@@ -9,56 +9,67 @@ import (
 	"time"
 )
 
-// ResponseWriterCounter is counter for http.ResponseWriter
+// ResponseWriterCounter is counter for http.ResponseWriter.
 type ResponseWriterCounter struct {
 	http.ResponseWriter
 	count      uint64
+	writes     uint64
 	started    time.Time
 	statusCode int
 }
 
-// NewResponseWriterCounter function create new ResponseWriterCounter
+// NewResponseWriterCounter function create new ResponseWriterCounter.
 func NewResponseWriterCounter(rw http.ResponseWriter) *ResponseWriterCounter {
 	return &ResponseWriterCounter{
 		ResponseWriter: rw,
 		started:        time.Now(),
+		statusCode:     0,
+		count:          0,
+		writes:         0,
 	}
 }
 
-// Write returns underlying Write result, while counting data size
+// Write returns underlying Write result, while counting data size.
 func (counter *ResponseWriterCounter) Write(buf []byte) (int, error) {
 	n, err := counter.ResponseWriter.Write(buf)
 	atomic.AddUint64(&counter.count, uint64(n))
-	return n, err
+	atomic.AddUint64(&counter.writes, 1)
+
+	return n, err //nolint:wrapcheck
 }
 
-// Header returns underlying Header result
+// Header returns underlying Header result.
 func (counter *ResponseWriterCounter) Header() http.Header {
 	return counter.ResponseWriter.Header()
 }
 
-// WriteHeader returns underlying WriteHeader, while setting Runtime header
+// WriteHeader returns underlying WriteHeader, while setting Runtime header.
 func (counter *ResponseWriterCounter) WriteHeader(statusCode int) {
 	counter.Header().Set("X-Runtime", fmt.Sprintf("%.6f", time.Since(counter.started).Seconds()))
 	counter.ResponseWriter.WriteHeader(statusCode)
 }
 
-// Hijack returns underlying Hijack
+// Hijack returns underlying Hijack.
 func (counter *ResponseWriterCounter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	return counter.ResponseWriter.(http.Hijacker).Hijack()
+	return counter.ResponseWriter.(http.Hijacker).Hijack() //nolint:wrapcheck
 }
 
-// Count function return counted bytes
+// Count function return counted bytes.
 func (counter *ResponseWriterCounter) Count() uint64 {
 	return atomic.LoadUint64(&counter.count)
 }
 
-// Started returns started value
+// Writes function returns count of Write() calls.
+func (counter *ResponseWriterCounter) Writes() uint64 {
+	return atomic.LoadUint64(&counter.writes)
+}
+
+// Started returns started value.
 func (counter *ResponseWriterCounter) Started() time.Time {
 	return counter.started
 }
 
-// StatusCode returns sent status code
+// StatusCode returns sent status code.
 func (counter *ResponseWriterCounter) StatusCode() int {
 	return counter.statusCode
 }

response_writer.go

@@ -1,23 +1,40 @@
-package datacounter
+package datacounter_test
 
 import (
+	"context"
 	"net/http"
 	"net/http/httptest"
 	"testing"
+
+	"golift.io/datacounter"
 )
 
 func TestResponseWriterCounter(t *testing.T) {
-	handler := func(w http.ResponseWriter, r *http.Request) {
-		w.Write(data)
+	t.Parallel()
+
+	var (
+		data    = []byte("Hello, World!")
+		dataLen = uint64(len(data))
+	)
+
+	handler := func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = w.Write(data)
 	}
-	req, err := http.NewRequest("GET", "http://example.com/foo", nil)
+
+	req, err := http.NewRequestWithContext(context.Background(), "GET", "http://example.com/foo", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
+
 	w := httptest.NewRecorder()
-	counter := NewResponseWriterCounter(w)
+	counter := datacounter.NewResponseWriterCounter(w)
 	handler(counter, req)
+
 	if counter.Count() != dataLen {
 		t.Fatalf("count mismatch len of test data: %d != %d", counter.Count(), len(data))
 	}
+
+	if counter.Writes() != 1 {
+		t.Fatalf("write mismatch len of test data: %d != 1", counter.Writes())
+	}
 }