Stdlib

This is a collection of standard library modules for go i use in my projects. The package offers a set of modules that are useful in most projects such as logging,tracing,pooling,caching,HTTP Request,etc.

Modules

• Cache
• HTTP Client
• SQL
• Pool

Usage

Importing

in code

import "github.com/karim-w/stdlib"

and

go get github.com/karim-w/stdlib

Cache

Caching tools are provided to make it easier to use caching in your projects. The package provides two types of caching, in memory and redis. The package uses the go-cache package for in memory caching and the go-redis package for redis caching.

Redis Cache

uses the go-redis package

cache, err := InitRedisCache("redis://:@localhost:6379/0")
if err != nil {
	t.Error(err)
}
err = cache.SetCtx(context.TODO(),"key",map[string]interface{}{
	"value":8,
})

In Memory Cache

uses the go-cache package

cache, err := InitInMemoryCache(
		time.Minute,
		time.Minute*2,
	)
if err != nil {
	t.Error(err)
}
err = cache.SetCtx(context.TODO(),"key",map[string]interface{}{
	"value":8,
})

Extentedable via

Logger

use the ZapLogger or any other logger that implements the Logger interface

var logger *zap.Logger
newCache := cache.WithLogger(logger)

Tracer

currently only support the applicationinsights tracer loacted at appinsights

var tracer *tracer.AppInsightsCore
newCache := cache.WithTracer(tracer)

HTTP Client

The package provides a wrapper for the http package to make it easier to use. The package provides a client that can be used to make HTTP requests. The package also provides a middleware that can be used to add tracing and logging to the requests.

Initializing

Plain client

var logger *zap.Logger
client := stdlib.ClientProvider()

Note: This function WILL panic if it fails to initialize a logger

Traceable client

var logger *zap.Logger
var tracer *tracer.AppInsightsCore
client := stdlib.TracedClientProvider(
	tracer,
	logger,
)

Client Options

type ClientOptions struct {
	Authorization string             //Authorization header
	ContentType   string             //Content-Type header
	Query         string             //Query string to append to the url
	Headers       *map[string]string //Headers to add to the request
	Timeout       *time.Time         //Timeout for the request
}

Usage

The client provides 5 Main Methods to make requests which are GET , POST , PUT , DELETE , PATCH. Each method takes a context, url, options, body and response. The response MUST be a pointer to the response type. GET And Del do not take a body in the request.

GET

Make a GET request

Response := interface{}		//any type
code,err := client.Get(
	context.TODO(),
	"http://localhost:8080",
	&stdlib.ClientOptions{},
	&Response,
)

Note: MUST pass a pointer to the response

POST

Make a POST request

Body := interface{}			//any type
Response := interface{}		//any type
code,err := client.Post(
	context.TODO(),
	"http://localhost:8080",
	&stdlib.ClientOptions{},
	Body,
	&Response,
)

Note: MUST pass a pointer to the response

PUT

Make a PUT request

Body := interface{}			//any type
Response := interface{}		//any type
code,err := client.Put(
	context.TODO(),
	"http://localhost:8080",
	&stdlib.ClientOptions{},
	Body,
	&Response,
)

Note: MUST pass a pointer to the response

PATCH

Make a PATCH request

Body := interface{}			//any type
Response := interface{}		//any type
code,err := client.Patch(
	context.TODO(),
	"http://localhost:8080",
	&stdlib.ClientOptions{},
	Body,
	&Response,
)

Note: MUST pass a pointer to the response

DELETE

Make a DELETE request

Response := interface{}		//any type
code,err := client.Del(
	context.TODO(),
	"http://localhost:8080",
	&stdlib.ClientOptions{},
	&Response,
)

Note: MUST pass a pointer to the response

Extentedable via

Authorization

client.SetAuthHandler(authProvider)

Auth provider must implement the AuthProvider interface

type AuthProvider interface {
	GetAuthHeader() string
}

SQL

The package provides a wrapper for the sql package to make it easier to use. The package provides a client that can be used to make SQL requests. The package also provides a middleware that can be used to add tracing and logging to the requests.

Initializing

Only supports Postgres, planning to add more

Will not support MSSQL

db := stdlib.NativeDatabaseProvider(
	databaseDriver,
	databaseConnectionString,
)

for tracing and logging use the TracedNativeDBWrapper function

db := stdlib.TracedNativeDBWrapper(
	databaseDriver,
	databaseConnectionString,
	tracer,
	dbName,
)
dbwithlogger := db.WithLogger(logger)

WARNING: Both functions will panic if they fail to initialize a logger

Usage

The client provides 3 Main Methods to make requests which are Query , Exec , QueryRow. Each with a variant for context they all take in query, args.

QueryRow

Make a Query request that returns a single row

var res int
row := db.Query(
	"SELECT COUNT(*) FROM table",
	[]interface{}{}...,
)
err:=row.Scan(&res)

QueryRowContext

Make a Query request with context that returns a single row

var res int
row := db.QueryContext(
	context.TODO(),
	"SELECT COUNT(*) FROM table",
	[]interface{}{}...,
)
err:=row.Scan(&res)

Exec

Execute a query that does not return a result rather the number of rows affected

res,err := db.Exec(
	"INSERT INTO table VALUES($1,$2)",
	[]interface{}{}...,
)

ExecContext

Execute a query that does not return a result rather the number of rows affected with context

res,err := db.ExecContext(
	context.TODO(),
	"INSERT INTO table VALUES($1,$2)",
	[]interface{}{}...,
)

QueryRow

Make a Query request that returns multiple rows

res := []int{}
rows,err := db.Query(
	"SELECT COUNT(*) FROM table",
	[]interface{}{}...,
)
for rows.Next(){
	var i int
	err:=rows.Scan(&i)
	if err!=nil{
		return err
	}
	res = append(res,i)
}

QueryRowContext

Make a Query request with context that returns multiple rows

res := []int{}
rows,err := db.QueryContext(
	context.TODO(),
	"SELECT COUNT(*) FROM table",
	[]interface{}{}...,
)
for rows.Next(){
	var i int
	err:=rows.Scan(&i)
	if err!=nil{
		return err
	}
	res = append(res,i)
}

Begin

Begin starts and returns a new transaction Object

tx,err := db.Begin()

BeginTx

Begin starts and returns a new transaction Object

tx,err := db.BeginTx(context.TODO(),opts) //opts is a *sql.TxOptions

Extentedable via

Logger

newDb := db.withLogger(logger) //*zap.Logger

Pooler

The package provides Pooling utility for any type of object. The package rotates the objects in the pool and provides a way to get the object from the pool in a round robin thread safe manner.

Initializing

type customType struct{
	//some fields
}

pool,err := stdlib.NewPooler(
	func () *customType{
		return &customType{}
	},
	&stdlib.PoolerOptions{
		PoolSize: 10,
	},
)

Usage

Get

Get an object from the pool

obj := pool.Get()

Size

Get the size of the pool

size := pool.Size()

Clear

Clear the pool

pool.Clear()

Tests

Coverage

Grid

Sunburst

Icicle