Viper v2 feedback

Viper is heading towards v2 and we would love to hear what you would like to see in it. Share your thoughts here: https://forms.gle/R6faU74qPRPAzchZ9

Thank you!

Go configuration with fangs!

Many Go projects are built using Viper including:

• Hugo
• EMC RexRay
• Imgur’s Incus
• Nanobox/Nanopack
• Docker Notary
• BloomApi
• doctl
• Clairctl
• Mercure
• Meshery
• Bearer
• Coder
• Vitess

go get github.com/spf13/viper

Note: Viper uses Go Modules to manage dependencies.

Viper is a complete configuration solution for Go applications including 12-Factor apps. It is designed to work within an application, and can handle all types of configuration needs and formats. It supports:

• setting defaults
• reading from JSON, TOML, YAML, HCL, envfile and Java properties config files
• live watching and re-reading of config files (optional)
• reading from environment variables
• reading from remote config systems (etcd or Consul), and watching changes
• reading from command line flags
• reading…

Gin is a web framework written in Go. It features a martini-like API with performance that is up to 40 times faster thanks to httprouter If you need performance and good productivity, you will love Gin.

Gin's key features are:

• Zero allocation router
• Speed
• Middleware support
• Crash-free
• JSON validation
• Route grouping
• Error management
• Built-in rendering
• Extensible

Gin requires Go version 1.21 or above.

With Go's module support, go [build|run|test] automatically fetches the necessary dependencies when you add the import in your code:

import "github.com/gin-gonic/gin"

Alternatively, use go get:

go get -u github.com/gin-gonic/gin

A basic example:

package main
import (
  "net/http"

  "github.com/gin-gonic/gin"
)

func main() {
  r := gin.Default()
  r.GET("/ping", func(c *gin.Context) {
    c.JSON(http.StatusOK,

This fork has had a few improvements by ourselves as well as several PR's merged from the original mgo repo that are currently awaiting review Changes are mostly geared towards performance improvements and bug fixes, though a few new features have been added.

Further PR's (with tests) are welcome, but please maintain backwards compatibility.

Detailed documentation of the API is available at GoDoc.

A sub-package that implements the BSON specification is also included, and may be used independently of the driver.

mgo is known to work well on (and has integration tests against) MongoDB v3.0, 3.2, 3.4 and 3.6.

MongoDB 4.0 is currently experimental - we would happily accept PRs to help improve support!

• Fixes attempting to authenticate before every query (details)
• Removes bulk update / delete batch size limitations (details)
• Adds native support for time.Duration marshalling…

go get -u go.uber.org/zap

Note that zap only supports the two most recent minor versions of Go.

In contexts where performance is nice, but not critical, use the SugaredLogger. It's 4-10x faster than other structured logging packages and includes both structured and printf-style APIs.

logger, _ := zap.NewProduction()
defer logger.Sync() // flushes buffer, if any
sugar := logger.Sugar()
sugar.Infow("failed to fetch URL",
  // Structured context as loosely typed key-value pairs.
  "url", url,
  "attempt", 3,
  "backoff", time.Second,
)
sugar.Infof("Failed to fetch URL: %s", url)

When performance and type safety are critical, use the Logger. It's even faster than the SugaredLogger and allocates far less, but it only…

Package uuid provides a pure Go implementation of Universally Unique Identifiers (UUID) variant as defined in RFC-9562. This package supports both the creation and parsing of UUIDs in different formats.

This package supports the following UUID versions:

• Version 1, based on timestamp and MAC address
• Version 3, based on MD5 hashing of a named value
• Version 4, based on random numbers
• Version 5, based on SHA-1 hashing of a named value
• Version 6, a k-sortable id based on timestamp, and field-compatible with v1
• Version 7, a k-sortable id based on timestamp

This project was originally forked from the github.com/satori/go.uuid repository after it appeared to be no longer maintained, while exhibiting critical flaws. We have decided to take over this project to ensure it receives regular maintenance for the benefit of the larger Go community.

We'd like to thank Maxim Bublis for his hard work on the…

The new repository can be found at: https://github.com/golang-jwt/jwt

For more information, see issue #462.

A go (or 'golang' for search engine friendliness) implementation of JSON Web Tokens

NEW VERSION COMING: There have been a lot of improvements suggested since the version 3.0.0 released in 2016. I'm working now on cutting two different releases: 3.2.0 will contain any non-breaking changes or enhancements. 4.0.0 will follow shortly which will include breaking changes. See the 4.0.0 milestone to get an idea of what's coming. If you have other ideas, or would like to participate in 4.0.0, now's the time. If you depend on this library and don't want to be interrupted, I recommend you use your dependency mangement tool to pin to version 3.

SECURITY NOTICE: Some older versions of Go have a security issue in the cryotp/elliptic. Recommendation is to upgrade to at least…

ℹ️ We are working on testify v2 and would love to hear what you'd like to see in it, have your say here: https://cutt.ly/testify

Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend.

Features include:

• Easy assertions
• Mocking
• Testing suite interfaces and functions

Get started:

• Install testify with one line of code, or update it with another
• For an introduction to writing test code in Go, see https://go.dev/doc/code#Testing
• Check out the API Documentation https://pkg.go.dev/github.com/stretchr/testify
• Use testifylint (via golanci-lint) to avoid common mistakes
• A little about Test-Driven Development (TDD)

The assert package provides some helpful methods that allow you to write better test code in Go.

• Prints friendly, easy to read failure descriptions
• Allows for very readable code
• Optionally annotate each assertion with a message

See it in action:

package

The yaml package enables Go programs to comfortably encode and decode YAML values. It was developed within Canonical as part of the juju project, and is based on a pure Go port of the well-known libyaml C library to parse and generate YAML data quickly and reliably.

The yaml package supports most of YAML 1.2, but preserves some behavior from 1.1 for backwards compatibility.

Specifically, as of v3 of the yaml package:

• YAML 1.1 bools (yes/no, on/off) are supported as long as they are being decoded into a typed bool value. Otherwise they behave as a string. Booleans in YAML 1.2 are true/false only.
• Octals encode and decode as 0777 per YAML 1.1, rather than 0o777 as specified in YAML 1.2, because most parsers still use the old format Octals in the 0o777 format are supported though, so new files…

Update, June 2023: This repo and tool are no longer maintained Please see go.uber.org/mock for a maintained fork instead.

gomock is a mocking framework for the Go programming language. It integrates well with Go's built-in testing package, but can be used in other contexts too.

Once you have installed Go, install the mockgen tool.

Note: If you have not done so already be sure to add $GOPATH/bin to your PATH.

To get the latest released version use:

GO111MODULE=on go get github.com/golang/mock/mockgen@v1.6.0

go install github.com/golang/mock/mockgen@v1.6.0

If you use mockgen in your CI pipeline, it may be more appropriate to fixate on a specific mockgen version. You should try to keep the library in sync with the version of mockgen used to generate your mocks.

mockgen has two modes of operation: source and reflect.

Source…

Modd is a developer tool that triggers commands and manages daemons in response to filesystem changes.

If you use modd, you should also look at devd, a compact HTTP daemon for developers Devd integrates with modd, allowing you to trigger in-browser livereload with modd.

The repo contains a set of example modd.conf files that you can look at for a quick idea of what modd can do:

Modd is a single binary with no external dependencies, released for OSX Windows, Linux, FreeBSD, NetBSD and OpenBSD. Go to the releases page, download the package for your OS, and copy the binary to somewhere on your PATH.

Alternatively, with Go 1.17+ installed, you can install…