How to measure both before and after byte size and time to compress

I want to gzip a string (it is actually a JSON response)

var b bytes.Buffer
gz := gzip.NewWriter(&b)
if _, err := gz.Write([]byte("YourDataHere")); err != nil {
    panic(err)
}

How can I easily output the size of bytes before and after compression and more importantly how can I time it takes to compress and decompress back to a string?

You can calculate the size as per Nipun Talukdar's comment.

len([]byte("YourDataHere"))
b.Len()

And use time.Now() and time.Since() to get the time taken.

var b bytes.Buffer
input := []byte("YourDataHere")

fmt.Println("Input size : ", len(input))

gz := gzip.NewWriter(&b)


start := time.Now() 

gz.Write(input)
if _, err := gz.Flush(); err != nil {
    	panic(err)
}


totalTime := time.Since(start) 

fmt.Println("Compressed size : ", b.Len(), "\nTime taken : ", totalTime)
gz.Close()

Same method can be applied with unzipping.
You can also create a support function that can do the timing.

func timer(startTime time.Time) {

totalTime := time.Since(startTime)
log.Println("Time taken : ",totalTime)

}

Usage : defer timer(time.Now()) at the start of the function.

There are examples of how to do this in Go here

https://golang.org/test/bench/go1/gzip_test.go

Thankfully it's BSD licensed...

// Copyright 2011 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This benchmark tests gzip and gunzip performance.
package go1 
import (
"bytes"
gz "compress/gzip"
"io"
"io/ioutil"
"testing"
)
var (
jsongunz = bytes.Repeat(jsonbytes, 10) 
jsongz   []byte
)
func init() {
var buf bytes.Buffer
c := gz.NewWriter(&buf)
c.Write(jsongunz)
c.Close()
jsongz = buf.Bytes()
}
func gzip() {
c := gz.NewWriter(ioutil.Discard)
if _, err := c.Write(jsongunz); err != nil {
panic(err)
}
if err := c.Close(); err != nil {
panic(err)
}
}
func gunzip() {
r, err := gz.NewReader(bytes.NewBuffer(jsongz))
if err != nil {
panic(err)
}
if _, err := io.Copy(ioutil.Discard, r); err != nil {
panic(err)
}
r.Close()
}
func BenchmarkGzip(b *testing.B) {
b.SetBytes(int64(len(jsongunz)))
for i := 0; i < b.N; i++ {
gzip()
}
}
func BenchmarkGunzip(b *testing.B) {
b.SetBytes(int64(len(jsongunz)))
for i := 0; i < b.N; i++ {
gunzip()
}
}

It's unfortunate that gzip.Writer can't report the number of compressed bytes written to the underlying stream. It gets more complicated when that underlying stream is not in-memory.

To solve this, I wrote a "counting io.Writer" that I place in between gzip.Writer and the underlying stream, so I can count and extract the number of compressed bytes written.

Try out the following code in the Go Playground.

package main

import (
	"compress/gzip"
	"fmt"
	"io"
	"os"
)

// countingWriter is an io.Writer that counts the total bytes written to it.
type countingWriter struct {
	w     io.Writer
	Count int
}

var _ io.Writer = &countingWriter{}

func newCountingWriter(w io.Writer) *countingWriter {
	return &countingWriter{w: w}
}

func (cw *countingWriter) Write(p []byte) (int, error) {
	n, err := cw.w.Write(p)
	cw.Count += n
	return n, err
}

func ExampleUse(w io.Writer) (int, error) {
	cw := newCountingWriter(w)
	zw, err := gzip.NewWriterLevel(cw, gzip.BestCompression)
	if err != nil {
		return 0, err
	}

	if _, err := zw.Write([]byte("hello world")); err != nil {
		return cw.Count, err
	}

	err = zw.Close()
	return cw.Count, err
}

func main() {
	n, err := ExampleUse(os.Stderr)
	if err != nil {
		panic(err)
	}
	fmt.Printf("wrote %d bytes\n", n)
}