Repository: TBD54566975/ssi-service
Pull request #36 (2022-05-04 05:16:02)

Switch to Logrus for logging
Fixes https://github.com/TBD54566975/ssi-service/issues/20


Patch:
diff --git a/README.md b/README.md
index 9b0b95b..7c4d5c9 100644
--- a/README.md
+++ b/README.md
@@ -77,12 +77,12 @@ You should then be able to send requests as follows:
 - [x] [DID Management](https://www.w3.org/TR/did-core/)
     - Using [did:key](https://w3c-ccg.github.io/did-method-key/)
 - [x] [Verifiable Credential Schema](https://w3c-ccg.github.io/vc-json-schemas/v2/index.html) Management
-- [] [Verifiable Credential](https://www.w3.org/TR/vc-data-model) Issuance & Verification
+- [ ] [Verifiable Credential](https://www.w3.org/TR/vc-data-model) Issuance & Verification
 - [ ] Requesting, Receiving, and the Validation of Verifiable Claims
   using [Presentation Exchange](https://identity.foundation/presentation-exchange/)
 - [ ] Applying for Verifiable Credentials using [Credential Manifest](https://identity.foundation/credential-manifest/)
 - [ ] Revocations of Verifiable Credentials using the [Status List 2021](https://w3c-ccg.github.io/vc-status-list-2021/)
-- [ ] [ID Hub](https://identity.foundation/identity-hub/spec/) Messaging
+- [ ] [Decentralized Web Node](https://identity.foundation/decentralized-web-node/spec/) Messaging
 
 ## Design Thinking
 
diff --git a/cmd/main.go b/cmd/main.go
index 712161c..adc11db 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -5,9 +5,9 @@ import (
 	"expvar"
 	"github.com/ardanlabs/conf"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/config"
 	"github.com/tbd54566975/ssi-service/pkg/server"
-	"log"
 	"net/http"
 	"os"
 	"os/signal"
@@ -18,34 +18,44 @@ const (
 	LogPrefix = config.ServiceName + ": "
 )
 
-func main() {
-	svcLog := log.New(os.Stdout, LogPrefix, log.LstdFlags|log.Lmicroseconds|log.Lshortfile)
+func init() {
+	// Log as JSON instead of the default ASCII formatter.
+	logrus.SetFormatter(&logrus.JSONFormatter{})
+
+	// Output to stdout instead of the default stderr
+	// Can be any io.Writer, see below for File example
+	logrus.SetOutput(os.Stdout)
 
-	svcLog.Println("Starting up...")
+	// Only log the warning severity or above.
+	logrus.SetLevel(logrus.InfoLevel)
+}
+
+func main() {
+	logrus.Info("Starting up...")
 
-	if err := run(svcLog); err != nil {
-		svcLog.Fatalf("main: error: %s", err.Error())
+	if err := run(); err != nil {
+		logrus.Fatalf("main: error: %s", err.Error())
 	}
 }
 
 // startup and shutdown logic
-func run(logger *log.Logger) error {
-	cfg, err := config.LoadConfig(logger, config.DefaultConfigPath)
+func run() error {
+	cfg, err := config.LoadConfig(config.DefaultConfigPath)
 	if err != nil {
-		logger.Fatalf("could not instantiate config: %s", err.Error())
+		logrus.Fatalf("could not instantiate config: %s", err.Error())
 	}
 
 	expvar.NewString("build").Set(cfg.Version.SVN)
 
-	logger.Printf("main: Started : Service initializing : version %q", cfg.Version.SVN)
-	defer logger.Println("main: Completed")
+	logrus.Infof("main: Started : Service initializing : version %q", cfg.Version.SVN)
+	defer logrus.Info("main: Completed")
 
-	out, err := conf.String(&cfg)
+	out, err := conf.String(cfg)
 	if err != nil {
 		return errors.Wrap(err, "serializing config")
 	}
 
-	logger.Printf("main: Config: \n%v\n", out)
+	logrus.Infof("main: Config: \n%v\n", out)
 
 	// create a channel of buffer size 1 to handle shutdown.
 	// buffer's size is 1 in order to ignore any additional ctrl+c
@@ -53,9 +63,9 @@ func run(logger *log.Logger) error {
 	shutdown := make(chan os.Signal, 1)
 	signal.Notify(shutdown, os.Interrupt, syscall.SIGTERM)
 
-	ssiServer, err := server.NewSSIServer(shutdown, logger, *cfg)
+	ssiServer, err := server.NewSSIServer(shutdown, *cfg)
 	if err != nil {
-		logger.Fatalf("could not start http services: %s", err.Error())
+		logrus.Fatalf("could not start http services: %s", err.Error())
 	}
 	api := http.Server{
 		Addr:         cfg.Server.APIHost,
@@ -67,7 +77,7 @@ func run(logger *log.Logger) error {
 	serverErrors := make(chan error, 1)
 
 	go func() {
-		logger.Printf("main: server started and listening on -> %s", api.Addr)
+		logrus.Infof("main: server started and listening on -> %s", api.Addr)
 
 		serverErrors <- api.ListenAndServe()
 	}()
@@ -76,7 +86,7 @@ func run(logger *log.Logger) error {
 	case err := <-serverErrors:
 		return errors.Wrap(err, "server error")
 	case sig := <-shutdown:
-		logger.Printf("main: shutdown signal received -> %v", sig)
+		logrus.Infof("main: shutdown signal received -> %v", sig)
 
 		ctx, cancel := context.WithTimeout(context.Background(), cfg.Server.ShutdownTimeout)
 		defer cancel()
diff --git a/config/config.go b/config/config.go
index f63a26c..07b5848 100644
--- a/config/config.go
+++ b/config/config.go
@@ -5,7 +5,7 @@ import (
 	"github.com/BurntSushi/toml"
 	"github.com/ardanlabs/conf"
 	"github.com/pkg/errors"
-	"log"
+	"github.com/sirupsen/logrus"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -13,7 +13,8 @@ import (
 )
 
 const (
-	DefaultConfigPath = "config.toml"
+	DefaultConfigPath = "config/config.toml"
+	ConfigFileName    = "config.toml"
 	ServiceName       = "ssi-service"
 	ConfigExtension   = ".toml"
 )
@@ -77,11 +78,11 @@ func (s *SchemaServiceConfig) IsEmpty() bool {
 
 // LoadConfig attempts to load a TOML config file from the given path, and coerce it into our object model.
 // Before loading, defaults are applied on certain properties, which are overwritten if specified in the TOML file.
-func LoadConfig(logger *log.Logger, path string) (*SSIServiceConfig, error) {
+func LoadConfig(path string) (*SSIServiceConfig, error) {
 	// no path, load default config
 	defaultConfig := false
 	if path == "" {
-		logger.Printf("no config path provided, loading default config...")
+		logrus.Info("no config path provided, loading default config...")
 		defaultConfig = true
 	} else if filepath.Ext(path) != ConfigExtension {
 		return nil, fmt.Errorf("path<%s> did not match the expected TOML format", path)
diff --git a/go.mod b/go.mod
index cd0f7b1..45e46d0 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.17
 
 require (
 	github.com/BurntSushi/toml v1.1.0
-	github.com/TBD54566975/ssi-sdk v0.0.0-20220419032604-6292424ef7ae
+	github.com/TBD54566975/ssi-sdk v0.0.0-20220503194418-84cb3c5a9c3e
 	github.com/ardanlabs/conf v1.5.0
 	github.com/boltdb/bolt v1.3.1
 	github.com/dimfeld/httptreemux/v5 v5.4.0
@@ -16,18 +16,15 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.7.1
 	go.opentelemetry.io/otel/trace v1.7.0
-	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
+	golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f
 	gopkg.in/go-playground/validator.v9 v9.31.0
-)
-
-require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
-	github.com/go-playground/validator/v10 v10.10.1 // indirect
+	github.com/go-playground/validator/v10 v10.11.0 // indirect
 	github.com/gobuffalo/logger v1.0.6 // indirect
 	github.com/gobuffalo/packd v1.0.1 // indirect
 	github.com/gobuffalo/packr/v2 v2.8.3 // indirect
-	github.com/goccy/go-json v0.9.6 // indirect
+	github.com/goccy/go-json v0.9.7 // indirect
 	github.com/karrick/godirwalk v1.16.1 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/lestrrat-go/backoff/v2 v2.0.8 // indirect
@@ -52,7 +49,7 @@ require (
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
 	go.opentelemetry.io/otel v1.7.0 // indirect
-	golang.org/x/sys v0.0.0-20220412211240-33da011f77ad // indirect
+	golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6 // indirect
 	golang.org/x/term v0.0.0-20220411215600-e5f449aeb171 // indirect
 	golang.org/x/text v0.3.7 // indirect
 	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
diff --git a/go.sum b/go.sum
index 6066338..9677313 100644
--- a/go.sum
+++ b/go.sum
@@ -41,8 +41,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
 github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I=
 github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/TBD54566975/ssi-sdk v0.0.0-20220419032604-6292424ef7ae h1:8f4RIwlopUS2hmj1ohvRjVnftZGVQzubNenZb/9q+sY=
-github.com/TBD54566975/ssi-sdk v0.0.0-20220419032604-6292424ef7ae/go.mod h1:dZf0M3fNzzqFH31ePuA8XfWQTS0RKEn6cDSjcwS+Ls0=
+github.com/TBD54566975/ssi-sdk v0.0.0-20220503194418-84cb3c5a9c3e h1:NBGiqzf2j1oIg/mDYtsAlem9aU67sqq+rxDjUSYwEgM=
+github.com/TBD54566975/ssi-sdk v0.0.0-20220503194418-84cb3c5a9c3e/go.mod h1:qkTs4OSwCUX+ja6Z//uWEKWSw6xAVzfBgmTLXaLVubQ=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/ardanlabs/conf v1.5.0 h1:5TwP6Wu9Xi07eLFEpiCUF3oQXh9UzHMDVnD3u/I5d5c=
 github.com/ardanlabs/conf v1.5.0/go.mod h1:ILsMo9dMqYzCxDjDXTiwMI0IgxOJd0MOiucbQY2wlJw=
@@ -102,8 +102,8 @@ github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb
 github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
 github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho=
 github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
-github.com/go-playground/validator/v10 v10.10.1 h1:uA0+amWMiglNZKZ9FJRKUAe9U3RX91eVn1JYXMWt7ig=
-github.com/go-playground/validator/v10 v10.10.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU=
+github.com/go-playground/validator/v10 v10.11.0 h1:0W+xRM511GY47Yy3bZUbJVitCNg2BOGlCyvTqsp/xIw=
+github.com/go-playground/validator/v10 v10.11.0/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU=
 github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
 github.com/gobuffalo/logger v1.0.0/go.mod h1:2zbswyIUa45I+c+FLXuWl9zSWEiVuthsk8ze5s8JvPs=
 github.com/gobuffalo/logger v1.0.6 h1:nnZNpxYo0zx+Aj9RfMPBm+x9zAU2OayFh/xrAWi34HU=
@@ -116,8 +116,9 @@ github.com/gobuffalo/packr v1.30.1/go.mod h1:ljMyFO2EcrnzsHsN99cvbq055Y9OhRrIavi
 github.com/gobuffalo/packr/v2 v2.5.1/go.mod h1:8f9c96ITobJlPzI44jj+4tHnEKNt0xXWSVlXRN9X1Iw=
 github.com/gobuffalo/packr/v2 v2.8.3 h1:xE1yzvnO56cUC0sTpKR3DIbxZgB54AftTFMhB2XEWlY=
 github.com/gobuffalo/packr/v2 v2.8.3/go.mod h1:0SahksCVcx4IMnigTjiFuyldmTrdTctXsOdiU5KwbKc=
-github.com/goccy/go-json v0.9.6 h1:5/4CtRQdtsX0sal8fdVhTaiMN01Ri8BExZZ8iRmHQ6E=
 github.com/goccy/go-json v0.9.6/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-json v0.9.7 h1:IcB+Aqpx/iMHu5Yooh7jEzJk1JZ7Pjtmys2ukPr7EeM=
+github.com/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -382,8 +383,9 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220214200702-86341886e292/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 h1:kUhD7nTDoI3fVd9G4ORWrbV5NY0liEs/Jg2pv5f+bBA=
 golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f h1:OeJjE6G4dgCY4PIXvIRQbE8+RX+uXZyGhUy/ksMGJoc=
+golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -530,8 +532,9 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad h1:ntjMns5wyP/fN65tdBD4g8J5w8n015+iIIs9rtjXkY0=
 golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6 h1:nonptSpoQ4vQjyraW20DXPAglgQfVnM9ZC6MmNLMR60=
+golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.0.0-20220411215600-e5f449aeb171 h1:EH1Deb8WZJ0xc0WK//leUHXcX9aLE5SymusoTmMZye8=
diff --git a/magefile.go b/magefile.go
index f5c00a8..90af7a5 100644
--- a/magefile.go
+++ b/magefile.go
@@ -5,8 +5,8 @@ package main
 
 import (
 	"fmt"
+	"github.com/sirupsen/logrus"
 	"io"
-	"log"
 	"os"
 	"os/exec"
 	"os/user"
@@ -104,7 +104,7 @@ func runGo(cmd string, args ...string) error {
 func installIfNotPresent(execName, goPackage string) error {
 	usr, err := user.Current()
 	if err != nil {
-		log.Fatal(err)
+		logrus.Fatal(err)
 		return err
 	}
 	pathOfExec := findOnPathOrGoPath(execName)
@@ -149,7 +149,7 @@ func findOnPath(execName string) string {
 func goPath() string {
 	usr, err := user.Current()
 	if err != nil {
-		log.Fatal(err)
+		logrus.Fatal(err)
 		return ""
 	}
 	goPath, goPathSet := os.LookupEnv("GOPATH")
diff --git a/pkg/server/middleware/errors.go b/pkg/server/middleware/errors.go
index 6f53d22..c223fe9 100644
--- a/pkg/server/middleware/errors.go
+++ b/pkg/server/middleware/errors.go
@@ -2,8 +2,8 @@ package middleware
 
 import (
 	"context"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
-	"log"
 	"net/http"
 
 	"go.opentelemetry.io/otel/trace"
@@ -12,7 +12,7 @@ import (
 // Errors handles errors coming out of the call stack. It detects safe application
 // errors (aka SafeError) that are used to respond to the requester in a
 // normalized way. Unexpected errors (status >= 500) are logged.
-func Errors(log *log.Logger) framework.Middleware {
+func Errors() framework.Middleware {
 	mw := func(handler framework.Handler) framework.Handler {
 		wrapped := func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
 			ctx, span := trace.SpanFromContext(ctx).TracerProvider().Tracer("logger").Start(ctx, "business.middleware.errors")
@@ -25,7 +25,7 @@ func Errors(log *log.Logger) framework.Middleware {
 
 			if err := handler(ctx, w, r); err != nil {
 				// log the error
-				log.Printf("%s : ERROR : %v", v.TraceID, err)
+				logrus.Printf("%s : ERROR : %v", v.TraceID, err)
 
 				// send an error response back to the requester.
 				if err := framework.RespondError(ctx, w, err); err != nil {
diff --git a/pkg/server/middleware/logger.go b/pkg/server/middleware/logger.go
index fc59afb..ffcb99d 100644
--- a/pkg/server/middleware/logger.go
+++ b/pkg/server/middleware/logger.go
@@ -2,8 +2,8 @@ package middleware
 
 import (
 	"context"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
-	"log"
 	"net/http"
 	"time"
 )
@@ -17,7 +17,7 @@ import (
 // 		TODO: add after format
 // 		TODO: add after example
 // TODO: make logging output configurable
-func Logger(log *log.Logger) framework.Middleware {
+func Logger() framework.Middleware {
 	mw := func(handler framework.Handler) framework.Handler {
 
 		wrapped := func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
@@ -26,14 +26,14 @@ func Logger(log *log.Logger) framework.Middleware {
 				return framework.NewShutdownError("Request state missing from context")
 			}
 
-			log.Printf("%s : started : %s %s -> %s",
+			logrus.Infof("%s : started : %s %s -> %s",
 				v.TraceID,
 				r.Method, r.URL.Path, r.RemoteAddr,
 			)
 
 			err := handler(ctx, w, r)
 
-			log.Printf("%s : completed : %s %s -> %s (%d) (%s)",
+			logrus.Infof("%s : completed : %s %s -> %s (%d) (%s)",
 				v.TraceID,
 				r.Method, r.URL.Path, r.RemoteAddr,
 				v.StatusCode, time.Since(v.Now),
diff --git a/pkg/server/middleware/panics.go b/pkg/server/middleware/panics.go
index 341fe07..6b5923f 100644
--- a/pkg/server/middleware/panics.go
+++ b/pkg/server/middleware/panics.go
@@ -2,8 +2,8 @@ package middleware
 
 import (
 	"context"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
-	"log"
 	"net/http"
 	"runtime/debug"
 
@@ -11,7 +11,7 @@ import (
 )
 
 // Panics recovers from panics and converts the panic into an error
-func Panics(log *log.Logger) framework.Middleware {
+func Panics() framework.Middleware {
 	mw := func(handler framework.Handler) framework.Handler {
 		wrapped := func(ctx context.Context, w http.ResponseWriter, r *http.Request) (err error) {
 
@@ -27,7 +27,7 @@ func Panics(log *log.Logger) framework.Middleware {
 					// log the stack trace for this panic'd goroutine
 					err = errors.Errorf("%s: \n%s", v.TraceID, debug.Stack())
 
-					log.Printf("%s: PANIC :\n%s", v.TraceID, debug.Stack())
+					logrus.Infof("%s: PANIC :\n%s", v.TraceID, debug.Stack())
 				}
 			}()
 
diff --git a/pkg/server/router/did.go b/pkg/server/router/did.go
index 4c52729..7ac4251 100644
--- a/pkg/server/router/did.go
+++ b/pkg/server/router/did.go
@@ -6,10 +6,10 @@ import (
 	"github.com/TBD54566975/ssi-sdk/crypto"
 	didsdk "github.com/TBD54566975/ssi-sdk/did"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
 	"github.com/tbd54566975/ssi-service/pkg/service/did"
 	svcframework "github.com/tbd54566975/ssi-service/pkg/service/framework"
-	"log"
 	"net/http"
 )
 
@@ -21,11 +21,10 @@ const (
 // DIDRouter represents the dependencies required to instantiate a DID-HTTP service
 type DIDRouter struct {
 	service *did.Service
-	logger  *log.Logger
 }
 
 // NewDIDRouter creates an HTP router for the DID Service
-func NewDIDRouter(s svcframework.Service, l *log.Logger) (*DIDRouter, error) {
+func NewDIDRouter(s svcframework.Service) (*DIDRouter, error) {
 	if s == nil {
 		return nil, errors.New("service cannot be nil")
 	}
@@ -35,7 +34,6 @@ func NewDIDRouter(s svcframework.Service, l *log.Logger) (*DIDRouter, error) {
 	}
 	return &DIDRouter{
 		service: didService,
-		logger:  l,
 	}, nil
 }
 
@@ -62,14 +60,14 @@ func (dr DIDRouter) CreateDIDByMethod(ctx context.Context, w http.ResponseWriter
 	method := framework.GetParam(ctx, MethodParam)
 	if method == nil {
 		errMsg := "create DID request missing method parameter"
-		dr.logger.Printf(errMsg)
+		logrus.Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
 	var request CreateDIDByMethodRequest
 	if err := framework.Decode(r, &request); err != nil {
 		errMsg := "invalid create DID request"
-		dr.logger.Printf(errors.Wrap(err, errMsg).Error())
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
@@ -78,7 +76,7 @@ func (dr DIDRouter) CreateDIDByMethod(ctx context.Context, w http.ResponseWriter
 	createDIDResponse, err := dr.service.CreateDIDByMethod(createDIDRequest)
 	if err != nil {
 		errMsg := fmt.Sprintf("could not create DID for method<%s> with key type: %s", *method, request.KeyType)
-		dr.logger.Printf(errMsg)
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusInternalServerError)
 	}
 
@@ -97,13 +95,13 @@ func (dr DIDRouter) GetDIDByMethod(ctx context.Context, w http.ResponseWriter, _
 	method := framework.GetParam(ctx, MethodParam)
 	if method == nil {
 		errMsg := "get DID by method request missing method parameter"
-		dr.logger.Printf(errMsg)
+		logrus.Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 	id := framework.GetParam(ctx, IDParam)
 	if id == nil {
 		errMsg := fmt.Sprintf("get DID request missing id parameter for method: %s", *method)
-		dr.logger.Printf(errMsg)
+		logrus.Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
@@ -113,7 +111,7 @@ func (dr DIDRouter) GetDIDByMethod(ctx context.Context, w http.ResponseWriter, _
 	gotDID, err := dr.service.GetDIDByMethod(getDIDRequest)
 	if err != nil {
 		errMsg := fmt.Sprintf("could not get DID for method<%s> with id: %s", *method, *id)
-		dr.logger.Printf(errors.Wrap(err, errMsg).Error())
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
diff --git a/pkg/server/router/readiness.go b/pkg/server/router/readiness.go
index 1a50550..58bb08a 100644
--- a/pkg/server/router/readiness.go
+++ b/pkg/server/router/readiness.go
@@ -5,20 +5,17 @@ import (
 	"fmt"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
 	svcframework "github.com/tbd54566975/ssi-service/pkg/service/framework"
-	"log"
 	"net/http"
 )
 
-func Readiness(services []svcframework.Service, log *log.Logger) framework.Handler {
+func Readiness(services []svcframework.Service) framework.Handler {
 	return readiness{
 		getter: servicesToGet{services},
-		log:    log,
 	}.ready
 }
 
 type readiness struct {
 	getter serviceGetter
-	log    *log.Logger
 }
 
 type GetReadinessResponse struct {
diff --git a/pkg/server/router/schema.go b/pkg/server/router/schema.go
index c6eee4b..df2b733 100644
--- a/pkg/server/router/schema.go
+++ b/pkg/server/router/schema.go
@@ -5,19 +5,18 @@ import (
 	"fmt"
 	schemalib "github.com/TBD54566975/ssi-sdk/credential/schema"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
 	svcframework "github.com/tbd54566975/ssi-service/pkg/service/framework"
 	"github.com/tbd54566975/ssi-service/pkg/service/schema"
-	"log"
 	"net/http"
 )
 
 type SchemaRouter struct {
 	service *schema.Service
-	logger  *log.Logger
 }
 
-func NewSchemaRouter(s svcframework.Service, l *log.Logger) (*SchemaRouter, error) {
+func NewSchemaRouter(s svcframework.Service) (*SchemaRouter, error) {
 	if s == nil {
 		return nil, errors.New("service cannot be nil")
 	}
@@ -27,7 +26,6 @@ func NewSchemaRouter(s svcframework.Service, l *log.Logger) (*SchemaRouter, erro
 	}
 	return &SchemaRouter{
 		service: schemaService,
-		logger:  l,
 	}, nil
 }
 
@@ -46,7 +44,7 @@ func (sr SchemaRouter) CreateSchema(ctx context.Context, w http.ResponseWriter,
 	var request CreateSchemaRequest
 	if err := framework.Decode(r, &request); err != nil {
 		errMsg := "invalid create schema request"
-		sr.logger.Printf(errors.Wrap(err, errMsg).Error())
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
@@ -54,7 +52,7 @@ func (sr SchemaRouter) CreateSchema(ctx context.Context, w http.ResponseWriter,
 	createSchemaResponse, err := sr.service.CreateSchema(req)
 	if err != nil {
 		errMsg := fmt.Sprintf("could not create schema with authoring DID: %s", request.Author)
-		sr.logger.Printf(errMsg)
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusInternalServerError)
 	}
 
@@ -70,7 +68,7 @@ func (sr SchemaRouter) GetSchemas(ctx context.Context, w http.ResponseWriter, r
 	gotSchemas, err := sr.service.GetSchemas()
 	if err != nil {
 		errMsg := "could not get schemas"
-		sr.logger.Printf(errors.Wrap(err, errMsg).Error())
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusInternalServerError)
 	}
 	resp := GetSchemasResponse{Schemas: gotSchemas.Schemas}
@@ -85,7 +83,7 @@ func (sr SchemaRouter) GetSchemaByID(ctx context.Context, w http.ResponseWriter,
 	id := framework.GetParam(ctx, IDParam)
 	if id == nil {
 		errMsg := "cannot get schema without ID parameter"
-		sr.logger.Printf(errMsg)
+		logrus.Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
@@ -93,7 +91,7 @@ func (sr SchemaRouter) GetSchemaByID(ctx context.Context, w http.ResponseWriter,
 	gotSchema, err := sr.service.GetSchemaByID(schema.GetSchemaByIDRequest{ID: *id})
 	if err != nil {
 		errMsg := fmt.Sprintf("could not get schema with id: %s", *id)
-		sr.logger.Printf(errors.Wrap(err, errMsg).Error())
+		logrus.WithError(err).Error(errMsg)
 		return framework.NewRequestErrorMsg(errMsg, http.StatusBadRequest)
 	}
 
diff --git a/pkg/server/server.go b/pkg/server/server.go
index 641fcdd..16cfbdf 100644
--- a/pkg/server/server.go
+++ b/pkg/server/server.go
@@ -5,14 +5,13 @@ package server
 import (
 	"fmt"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/config"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
-	svcframework "github.com/tbd54566975/ssi-service/pkg/service/framework"
-
 	"github.com/tbd54566975/ssi-service/pkg/server/middleware"
 	"github.com/tbd54566975/ssi-service/pkg/server/router"
 	"github.com/tbd54566975/ssi-service/pkg/service"
-	"log"
+	svcframework "github.com/tbd54566975/ssi-service/pkg/service/framework"
 	"net/http"
 	"os"
 	"path"
@@ -26,18 +25,17 @@ const (
 
 // SSIServer exposes all dependencies needed to run a http server and all its services
 type SSIServer struct {
-	*log.Logger
 	*framework.Server
 	*config.ServerConfig
 	*service.SSIService
 }
 
 // NewSSIServer does two things: instantiates all service and registers their HTTP bindings
-func NewSSIServer(shutdown chan os.Signal, logger *log.Logger, config config.SSIServiceConfig) (*SSIServer, error) {
+func NewSSIServer(shutdown chan os.Signal, config config.SSIServiceConfig) (*SSIServer, error) {
 	// creates an HTTP server from the framework, and wrap it to extend it for the SSIS
-	middlewares := []framework.Middleware{middleware.Logger(logger), middleware.Errors(logger), middleware.Metrics(), middleware.Panics(logger)}
+	middlewares := []framework.Middleware{middleware.Logger(), middleware.Errors(), middleware.Metrics(), middleware.Panics()}
 	httpServer := framework.NewHTTPServer(shutdown, middlewares...)
-	ssi, err := service.InstantiateSSIService(logger, config.Services)
+	ssi, err := service.InstantiateSSIService(config.Services)
 	if err != nil {
 		return nil, err
 	}
@@ -47,24 +45,23 @@ func NewSSIServer(shutdown chan os.Signal, logger *log.Logger, config config.SSI
 
 	// service-level routers
 	httpServer.Handle(http.MethodGet, "/health", router.Health)
-	httpServer.Handle(http.MethodGet, "/readiness", router.Readiness(services, logger))
+	httpServer.Handle(http.MethodGet, "/readiness", router.Readiness(services))
 
 	// create the server instance to be returned
 	server := SSIServer{
-		Logger:       logger,
 		Server:       httpServer,
 		SSIService:   ssi,
 		ServerConfig: &config.Server,
 	}
 
 	// start all services and their routers
-	log.Printf("Starting [%d] services...\n", len(services))
+	logrus.Infof("Starting [%d] services...\n", len(services))
 	for _, s := range services {
 		if err := server.instantiateRouter(s); err != nil {
-			errMsg := fmt.Sprintf("unable to instaniate service<%s>: %s", s.Type(), err.Error())
-			log.Fatalf(errMsg)
+			logrus.WithError(err).Fatalf("unable to instaniate service<%s>", s.Type())
+			return nil, err
 		}
-		log.Printf("Service<%s> started successfully\n", s.Type())
+		logrus.Infof("Service<%s> started successfully", s.Type())
 	}
 
 	return &server, nil
@@ -86,7 +83,7 @@ func (s *SSIServer) instantiateRouter(service svcframework.Service) error {
 
 // DecentralizedIdentityAPI registers all HTTP router for the DID Service
 func (s *SSIServer) DecentralizedIdentityAPI(service svcframework.Service) error {
-	didRouter, err := router.NewDIDRouter(service, s.Logger)
+	didRouter, err := router.NewDIDRouter(service)
 	if err != nil {
 		return errors.Wrap(err, "could not create DID router")
 	}
@@ -101,7 +98,7 @@ func (s *SSIServer) DecentralizedIdentityAPI(service svcframework.Service) error
 
 // SchemaAPI registers all HTTP router for the Schema Service
 func (s *SSIServer) SchemaAPI(service svcframework.Service) error {
-	schemaRouter, err := router.NewSchemaRouter(service, s.Logger)
+	schemaRouter, err := router.NewSchemaRouter(service)
 	if err != nil {
 		return errors.Wrap(err, "could not create Schema router")
 	}
diff --git a/pkg/service/did/did.go b/pkg/service/did/did.go
index 95968d9..c34fed2 100644
--- a/pkg/service/did/did.go
+++ b/pkg/service/did/did.go
@@ -3,11 +3,11 @@ package did
 import (
 	"fmt"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/config"
 	didstorage "github.com/tbd54566975/ssi-service/pkg/service/did/storage"
 	"github.com/tbd54566975/ssi-service/pkg/service/framework"
 	"github.com/tbd54566975/ssi-service/pkg/storage"
-	"log"
 )
 
 type Method string
@@ -20,7 +20,6 @@ type Service struct {
 	// supported DID methods
 	handlers map[Method]MethodHandler
 	storage  didstorage.Storage
-	logger   *log.Logger
 	config   config.DIDServiceConfig
 }
 
@@ -55,7 +54,7 @@ func (s Service) CreateDIDByMethod(request CreateDIDRequest) (*CreateDIDResponse
 	handler, err := s.getHandler(request.Method)
 	if err != nil {
 		errMsg := fmt.Sprintf("could not get handler for method<%s>", request.Method)
-		s.logger.Printf(errMsg)
+		logrus.WithError(err).Error(errMsg)
 		return nil, errors.New(errMsg)
 	}
 	return handler.CreateDID(request)
@@ -65,7 +64,7 @@ func (s Service) GetDIDByMethod(request GetDIDRequest) (*GetDIDResponse, error)
 	handler, err := s.getHandler(request.Method)
 	if err != nil {
 		errMsg := fmt.Sprintf("could not get handler for method<%s>", request.Method)
-		s.logger.Printf(errMsg)
+		logrus.WithError(err).Error(errMsg)
 		return nil, errors.New(errMsg)
 	}
 	return handler.GetDID(request)
@@ -74,7 +73,9 @@ func (s Service) GetDIDByMethod(request GetDIDRequest) (*GetDIDResponse, error)
 func (s Service) getHandler(method Method) (MethodHandler, error) {
 	handler, ok := s.handlers[method]
 	if !ok {
-		return nil, fmt.Errorf("could not get handler for DID method: %s", method)
+		err := fmt.Errorf("could not get handler for DID method: %s", method)
+		logrus.WithError(err).Error()
+		return nil, err
 	}
 	return handler, nil
 }
@@ -85,7 +86,7 @@ type MethodHandler interface {
 	GetDID(request GetDIDRequest) (*GetDIDResponse, error)
 }
 
-func NewDIDService(log *log.Logger, config config.DIDServiceConfig, s storage.ServiceStorage) (*Service, error) {
+func NewDIDService(config config.DIDServiceConfig, s storage.ServiceStorage) (*Service, error) {
 	didStorage, err := didstorage.NewDIDStorage(s)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not instantiate DID storage for the DID service")
@@ -93,13 +94,12 @@ func NewDIDService(log *log.Logger, config config.DIDServiceConfig, s storage.Se
 	svc := Service{
 		storage:  didStorage,
 		handlers: make(map[Method]MethodHandler),
-		logger:   log,
 	}
 
 	// instantiate all handlers for DID methods
 	for _, m := range config.Methods {
 		if err := svc.instantiateHandlerForMethod(Method(m)); err != nil {
-			return nil, errors.Wrap(err, "could not instantiate DID svc")
+			return nil, errors.Wrap(err, "could not instantiate DID service")
 		}
 	}
 	return &svc, nil
@@ -110,11 +110,15 @@ func (s *Service) instantiateHandlerForMethod(method Method) error {
 	case KeyMethod:
 		handler, err := newKeyDIDHandler(s.storage)
 		if err != nil {
-			return fmt.Errorf("could not instnatiate did:%s handler", KeyMethod)
+			err := fmt.Errorf("could not instnatiate did:%s handler", KeyMethod)
+			logrus.WithError(err).Error()
+			return err
 		}
 		s.handlers[method] = handler
 	default:
-		return fmt.Errorf("unsupported DID method: %s", method)
+		err := fmt.Errorf("unsupported DID method: %s", method)
+		logrus.WithError(err).Error()
+		return err
 	}
 	return nil
 }
diff --git a/pkg/service/schema/schema.go b/pkg/service/schema/schema.go
index 8bc79a1..e2d48f7 100644
--- a/pkg/service/schema/schema.go
+++ b/pkg/service/schema/schema.go
@@ -7,17 +7,16 @@ import (
 	schemalib "github.com/TBD54566975/ssi-sdk/schema"
 	"github.com/google/uuid"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/config"
 	"github.com/tbd54566975/ssi-service/pkg/service/framework"
 	schemastorage "github.com/tbd54566975/ssi-service/pkg/service/schema/storage"
 	"github.com/tbd54566975/ssi-service/pkg/storage"
-	"log"
 	"time"
 )
 
 type Service struct {
 	storage schemastorage.Storage
-	log     *log.Logger
 	config  config.SchemaServiceConfig
 }
 
@@ -39,14 +38,13 @@ func (s Service) Config() config.SchemaServiceConfig {
 	return s.config
 }
 
-func NewSchemaService(logger *log.Logger, config config.SchemaServiceConfig, s storage.ServiceStorage) (*Service, error) {
+func NewSchemaService(config config.SchemaServiceConfig, s storage.ServiceStorage) (*Service, error) {
 	schemaStorage, err := schemastorage.NewSchemaStorage(s)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not instantiate Schema storage for the Schema service")
 	}
 	return &Service{
 		storage: schemaStorage,
-		log:     logger,
 		config:  config,
 	}, nil
 }
@@ -60,7 +58,9 @@ func (s Service) CreateSchema(request CreateSchemaRequest) (*CreateSchemaRespons
 		return nil, errors.Wrap(err, "could not marshal schema in request")
 	}
 	if err := schemalib.IsValidJSONSchema(string(schemaBytes)); err != nil {
-		return nil, errors.Wrap(err, "provided value is not a valid JSON schema")
+		err := errors.Wrap(err, "provided value is not a valid JSON schema")
+		logrus.WithError(err).Error()
+		return nil, err
 	}
 
 	schemaID := uuid.NewString()
@@ -76,7 +76,9 @@ func (s Service) CreateSchema(request CreateSchemaRequest) (*CreateSchemaRespons
 
 	storedSchema := schemastorage.StoredSchema{Schema: schemaValue}
 	if err := s.storage.StoreSchema(storedSchema); err != nil {
-		return nil, errors.Wrap(err, "could not store schema")
+		err := errors.Wrap(err, "could not store schema")
+		logrus.WithError(err).Error()
+		return nil, err
 	}
 
 	return &CreateSchemaResponse{ID: schemaID, Schema: schemaValue}, nil
@@ -99,10 +101,14 @@ func (s Service) GetSchemas() (*GetSchemasResponse, error) {
 func (s Service) GetSchemaByID(request GetSchemaByIDRequest) (*GetSchemaByIDResponse, error) {
 	gotSchema, err := s.storage.GetSchema(request.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting schema: %s", request.ID)
+		err := errors.Wrapf(err, "error getting schema: %s", request.ID)
+		logrus.WithError(err).Error()
+		return nil, err
 	}
 	if gotSchema == nil {
-		return nil, fmt.Errorf("schema with id<%s> could not be found", request.ID)
+		err := fmt.Errorf("schema with id<%s> could not be found", request.ID)
+		logrus.WithError(err).Error()
+		return nil, err
 	}
 	return &GetSchemaByIDResponse{Schema: gotSchema.Schema}, nil
 }
diff --git a/pkg/service/service.go b/pkg/service/service.go
index 220709a..a5ed233 100644
--- a/pkg/service/service.go
+++ b/pkg/service/service.go
@@ -3,37 +3,33 @@ package service
 import (
 	"fmt"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/tbd54566975/ssi-service/config"
 	"github.com/tbd54566975/ssi-service/pkg/service/did"
 	"github.com/tbd54566975/ssi-service/pkg/service/framework"
 	"github.com/tbd54566975/ssi-service/pkg/service/schema"
 	"github.com/tbd54566975/ssi-service/pkg/storage"
-	"log"
 )
 
 // SSIService represents all services and their dependencies independent of transport
 type SSIService struct {
-	*log.Logger
 	services []framework.Service
 	config   config.ServicesConfig
 }
 
 // InstantiateSSIService creates a new instance of the SSIS which instantiates all services and their
 // dependencies independent of transport.
-func InstantiateSSIService(logger *log.Logger, config config.ServicesConfig) (*SSIService, error) {
-	if logger == nil {
-		return nil, errors.New("logger not initialized")
-	}
+func InstantiateSSIService(config config.ServicesConfig) (*SSIService, error) {
 	if err := validateServiceConfig(config); err != nil {
-		errMsg := fmt.Sprintf("could not instantiate SSI Service, invalid config: %s", err.Error())
-		log.Printf(errMsg)
-		return nil, errors.New(errMsg)
+		err := errors.Wrapf(err, "could not instantiate SSI Service, invalid config")
+		logrus.WithError(err).Error()
+		return nil, err
 	}
-	services, err := instantiateServices(logger, config)
+	services, err := instantiateServices(config)
 	if err != nil {
-		errMsg := fmt.Sprintf("could not instantiate the verifiable credentials service: %s", err.Error())
-		log.Printf(errMsg)
-		return nil, errors.New(errMsg)
+		err := errors.Wrapf(err, "could not instantiate the verifiable credentials service")
+		logrus.WithError(err).Error()
+		return nil, err
 	}
 	return &SSIService{services: services}, nil
 }
@@ -57,18 +53,18 @@ func (ssi *SSIService) GetServices() []framework.Service {
 }
 
 // instantiateServices begins all instantiates and their dependencies
-func instantiateServices(logger *log.Logger, config config.ServicesConfig) ([]framework.Service, error) {
-	storageProvider, err := storage.NewStorage(storage.Storage(config.StorageProvider), logger)
+func instantiateServices(config config.ServicesConfig) ([]framework.Service, error) {
+	storageProvider, err := storage.NewStorage(storage.Storage(config.StorageProvider))
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not instantiate storage provider: %s", config.StorageProvider)
 	}
 
-	didService, err := did.NewDIDService(logger, config.DIDConfig, storageProvider)
+	didService, err := did.NewDIDService(config.DIDConfig, storageProvider)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not instantiate the DID service")
 	}
 
-	schemaService, err := schema.NewSchemaService(logger, config.SchemaConfig, storageProvider)
+	schemaService, err := schema.NewSchemaService(config.SchemaConfig, storageProvider)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not instantiate the schema service")
 	}
diff --git a/pkg/storage/bolt.go b/pkg/storage/bolt.go
index 8bad769..ee5b8da 100644
--- a/pkg/storage/bolt.go
+++ b/pkg/storage/bolt.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"github.com/boltdb/bolt"
 	"github.com/pkg/errors"
-	"log"
+	"github.com/sirupsen/logrus"
 	"strings"
 	"time"
 )
@@ -14,21 +14,20 @@ const (
 )
 
 type BoltDB struct {
-	logger *log.Logger
-	db     *bolt.DB
+	db *bolt.DB
 }
 
 // NewBoltDB instantiates a file-based storage instance for Bolt https://github.com/boltdb/bolt
-func NewBoltDB(logger *log.Logger) (*BoltDB, error) {
-	return NewBoltDBWithFile(logger, DBFile)
+func NewBoltDB() (*BoltDB, error) {
+	return NewBoltDBWithFile(DBFile)
 }
 
-func NewBoltDBWithFile(logger *log.Logger, filePath string) (*BoltDB, error) {
+func NewBoltDBWithFile(filePath string) (*BoltDB, error) {
 	db, err := bolt.Open(filePath, 0600, &bolt.Options{Timeout: 3 * time.Second})
 	if err != nil {
 		return nil, err
 	}
-	return &BoltDB{logger: logger, db: db}, nil
+	return &BoltDB{db: db}, nil
 }
 
 func (b *BoltDB) Close() error {
@@ -53,7 +52,7 @@ func (b *BoltDB) Read(namespace, key string) ([]byte, error) {
 	err := b.db.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte(namespace))
 		if bucket == nil {
-			b.logger.Printf("namespace<%s> does not exist", namespace)
+			logrus.Infof("namespace<%s> does not exist", namespace)
 			return nil
 		}
 		result = bucket.Get([]byte(key))
@@ -67,7 +66,7 @@ func (b *BoltDB) ReadAll(namespace string) (map[string][]byte, error) {
 	err := b.db.View(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket([]byte(namespace))
 		if bucket == nil {
-			b.logger.Printf("namespace<%s> does not exist", namespace)
+			logrus.Printf("namespace<%s> does not exist", namespace)
 			return nil
 		}
 		cursor := bucket.Cursor()
diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go
index 66d3efd..59f17b2 100644
--- a/pkg/storage/storage.go
+++ b/pkg/storage/storage.go
@@ -2,7 +2,6 @@ package storage
 
 import (
 	"fmt"
-	"log"
 )
 
 type Storage string
@@ -22,10 +21,10 @@ type ServiceStorage interface {
 }
 
 // NewStorage creates a new storage provider based on the input
-func NewStorage(storageProvider Storage, logger *log.Logger) (ServiceStorage, error) {
+func NewStorage(storageProvider Storage) (ServiceStorage, error) {
 	switch storageProvider {
 	case Bolt:
-		return NewBoltDB(logger)
+		return NewBoltDB()
 	default:
 		return nil, fmt.Errorf("unsupported storage provider: %s", storageProvider)
 	}


Test patch:
diff --git a/config/config_test.go b/config/config_test.go
index ac03804..a829f67 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -2,14 +2,11 @@ package config
 
 import (
 	"github.com/stretchr/testify/assert"
-	"log"
-	"os"
 	"testing"
 )
 
 func TestConfig(t *testing.T) {
-	logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-	config, err := LoadConfig(logger, DefaultConfigPath)
+	config, err := LoadConfig(ConfigFileName)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, config)
 
diff --git a/pkg/server/router/did_test.go b/pkg/server/router/did_test.go
index c76d057..7c5a0e7 100644
--- a/pkg/server/router/did_test.go
+++ b/pkg/server/router/did_test.go
@@ -7,7 +7,6 @@ import (
 	"github.com/tbd54566975/ssi-service/pkg/service/did"
 	"github.com/tbd54566975/ssi-service/pkg/service/framework"
 	"github.com/tbd54566975/ssi-service/pkg/storage"
-	"log"
 	"os"
 	"testing"
 )
@@ -20,28 +19,26 @@ func TestDIDRouter(t *testing.T) {
 	})
 
 	t.Run("Nil Service", func(tt *testing.T) {
-		didRouter, err := NewDIDRouter(nil, nil)
+		didRouter, err := NewDIDRouter(nil)
 		assert.Error(tt, err)
 		assert.Empty(tt, didRouter)
 		assert.Contains(tt, err.Error(), "service cannot be nil")
 	})
 
 	t.Run("Bad Service", func(tt *testing.T) {
-		didRouter, err := NewDIDRouter(&testService{}, nil)
+		didRouter, err := NewDIDRouter(&testService{})
 		assert.Error(tt, err)
 		assert.Empty(tt, didRouter)
 		assert.Contains(tt, err.Error(), "could not create DID router with service type: test")
 	})
 
 	t.Run("DID Service Test", func(tt *testing.T) {
-		logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-
-		bolt, err := storage.NewBoltDB(logger)
+		bolt, err := storage.NewBoltDB()
 		assert.NoError(tt, err)
 		assert.NotEmpty(tt, bolt)
 
 		serviceConfig := config.DIDServiceConfig{Methods: []string{string(did.KeyMethod)}}
-		didService, err := did.NewDIDService(logger, serviceConfig, bolt)
+		didService, err := did.NewDIDService(serviceConfig, bolt)
 		assert.NoError(tt, err)
 		assert.NotEmpty(tt, didService)
 
diff --git a/pkg/server/router/schema_test.go b/pkg/server/router/schema_test.go
index 4697856..5c9aaf3 100644
--- a/pkg/server/router/schema_test.go
+++ b/pkg/server/router/schema_test.go
@@ -6,7 +6,6 @@ import (
 	"github.com/tbd54566975/ssi-service/pkg/service/framework"
 	"github.com/tbd54566975/ssi-service/pkg/service/schema"
 	"github.com/tbd54566975/ssi-service/pkg/storage"
-	"log"
 	"os"
 	"testing"
 )
@@ -19,28 +18,26 @@ func TestSchemaRouter(t *testing.T) {
 	})
 
 	t.Run("Nil Service", func(tt *testing.T) {
-		schemaRouter, err := NewSchemaRouter(nil, nil)
+		schemaRouter, err := NewSchemaRouter(nil)
 		assert.Error(tt, err)
 		assert.Empty(tt, schemaRouter)
 		assert.Contains(tt, err.Error(), "service cannot be nil")
 	})
 
 	t.Run("Bad Service", func(tt *testing.T) {
-		schemaRouter, err := NewSchemaRouter(&testService{}, nil)
+		schemaRouter, err := NewSchemaRouter(&testService{})
 		assert.Error(tt, err)
 		assert.Empty(tt, schemaRouter)
 		assert.Contains(tt, err.Error(), "could not create schema router with service type: test")
 	})
 
 	t.Run("Schema Service Test", func(tt *testing.T) {
-		logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-
-		bolt, err := storage.NewBoltDB(logger)
+		bolt, err := storage.NewBoltDB()
 		assert.NoError(tt, err)
 		assert.NotEmpty(tt, bolt)
 
 		serviceConfig := config.SchemaServiceConfig{BaseServiceConfig: &config.BaseServiceConfig{Name: "schema"}}
-		schemaService, err := schema.NewSchemaService(logger, serviceConfig, bolt)
+		schemaService, err := schema.NewSchemaService(serviceConfig, bolt)
 		assert.NoError(tt, err)
 		assert.NotEmpty(tt, schemaService)
 
diff --git a/pkg/server/server_test.go b/pkg/server/server_test.go
index e6d4aec..daa0e2e 100644
--- a/pkg/server/server_test.go
+++ b/pkg/server/server_test.go
@@ -18,7 +18,6 @@ import (
 	"github.com/tbd54566975/ssi-service/pkg/service/schema"
 	"github.com/tbd54566975/ssi-service/pkg/storage"
 	"io"
-	"log"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -33,10 +32,9 @@ func TestHealthCheckAPI(t *testing.T) {
 	})
 
 	shutdown := make(chan os.Signal, 1)
-	logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-	serviceConfig, err := config.LoadConfig(logger, "")
+	serviceConfig, err := config.LoadConfig("")
 	assert.NoError(t, err)
-	server, err := NewSSIServer(shutdown, logger, *serviceConfig)
+	server, err := NewSSIServer(shutdown, *serviceConfig)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, server)
 
@@ -62,18 +60,17 @@ func TestReadinessAPI(t *testing.T) {
 	})
 
 	shutdown := make(chan os.Signal, 1)
-	logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-	serviceConfig, err := config.LoadConfig(logger, "")
+	serviceConfig, err := config.LoadConfig("")
 	assert.NoError(t, err)
 
-	server, err := NewSSIServer(shutdown, logger, *serviceConfig)
+	server, err := NewSSIServer(shutdown, *serviceConfig)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, server)
 
 	req := httptest.NewRequest(http.MethodGet, "https://ssi-service.com/readiness", nil)
 	w := httptest.NewRecorder()
 
-	handler := router.Readiness(nil, logger)
+	handler := router.Readiness(nil)
 	err = handler(newRequestContext(), w, req)
 	assert.NoError(t, err)
 	assert.Equal(t, http.StatusOK, w.Result().StatusCode)
@@ -223,19 +220,17 @@ func TestDIDAPI(t *testing.T) {
 
 func newDIDService(t *testing.T) *router.DIDRouter {
 	// set up DID service
-	logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-
-	bolt, err := storage.NewBoltDB(logger)
+	bolt, err := storage.NewBoltDB()
 	require.NoError(t, err)
 	require.NotEmpty(t, bolt)
 
 	serviceConfig := config.DIDServiceConfig{Methods: []string{string(did.KeyMethod)}}
-	didService, err := did.NewDIDService(logger, serviceConfig, bolt)
+	didService, err := did.NewDIDService(serviceConfig, bolt)
 	require.NoError(t, err)
 	require.NotEmpty(t, didService)
 
 	// create router for service
-	didRouter, err := router.NewDIDRouter(didService, logger)
+	didRouter, err := router.NewDIDRouter(didService)
 	require.NoError(t, err)
 	require.NotEmpty(t, didRouter)
 
@@ -381,18 +376,16 @@ func TestSchemaAPI(t *testing.T) {
 
 func newSchemaService(t *testing.T) *router.SchemaRouter {
 	// set up DID service
-	logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-
-	bolt, err := storage.NewBoltDB(logger)
+	bolt, err := storage.NewBoltDB()
 	require.NoError(t, err)
 	require.NotEmpty(t, bolt)
 
-	schemaService, err := schema.NewSchemaService(logger, config.SchemaServiceConfig{}, bolt)
+	schemaService, err := schema.NewSchemaService(config.SchemaServiceConfig{}, bolt)
 	require.NoError(t, err)
 	require.NotEmpty(t, schemaService)
 
 	// create router for service
-	schemaRouter, err := router.NewSchemaRouter(schemaService, logger)
+	schemaRouter, err := router.NewSchemaRouter(schemaService)
 	require.NoError(t, err)
 	require.NotEmpty(t, schemaRouter)
 
diff --git a/pkg/storage/bolt_test.go b/pkg/storage/bolt_test.go
index 12ef51b..5cd1bd1 100644
--- a/pkg/storage/bolt_test.go
+++ b/pkg/storage/bolt_test.go
@@ -3,15 +3,12 @@ package storage
 import (
 	"encoding/json"
 	"github.com/stretchr/testify/assert"
-	"log"
 	"os"
 	"testing"
 )
 
 func TestBoltDB(t *testing.T) {
-	logger := log.New(os.Stdout, "ssi-test", log.LstdFlags)
-
-	db, err := NewBoltDBWithFile(logger, "test.db")
+	db, err := NewBoltDBWithFile("test.db")
 	assert.NoError(t, err)
 	assert.NotEmpty(t, db)