switch to go-kit/log (#1575)

Signed-off-by: yeya24 <yb532204897@gmail.com>

158 files changed, 3434 insertions, 4636 deletions

diff --git a/collector/arp_linux.go b/collector/arp_linux.go
index 49c437e..6a18879 100644
--- a/collector/arp_linux.go
+++ b/collector/arp_linux.go
@@ -22,11 +22,13 @@ import (
         "os"
         "strings"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
 type arpCollector struct {
         entries *prometheus.Desc
+        logger  log.Logger
 }
 
 func init() {
@@ -34,13 +36,14 @@ func init() {
 }
 
 // NewARPCollector returns a new Collector exposing ARP stats.
-func NewARPCollector() (Collector, error) {
+func NewARPCollector(logger log.Logger) (Collector, error) {
         return &arpCollector{
                 entries: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, "arp", "entries"),
                         "ARP entries by device",
                         []string{"device"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/bcache_linux.go b/collector/bcache_linux.go
index da4eab5..20995c7 100644
--- a/collector/bcache_linux.go
+++ b/collector/bcache_linux.go
@@ -18,6 +18,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/bcache"
 )
@@ -28,19 +29,21 @@ func init() {
 
 // A bcacheCollector is a Collector which gathers metrics from Linux bcache.
 type bcacheCollector struct {
-        fs bcache.FS
+        fs     bcache.FS
+        logger log.Logger
 }
 
 // NewBcacheCollector returns a newly allocated bcacheCollector.
 // It exposes a number of Linux bcache statistics.
-func NewBcacheCollector() (Collector, error) {
+func NewBcacheCollector(logger log.Logger) (Collector, error) {
         fs, err := bcache.NewFS(*sysPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open sysfs: %w", err)
         }
 
         return &bcacheCollector{
-                fs: fs,
+                fs:     fs,
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/bonding_linux.go b/collector/bonding_linux.go
index f67e2a3..771786b 100644
--- a/collector/bonding_linux.go
+++ b/collector/bonding_linux.go
@@ -22,12 +22,14 @@ import (
         "path/filepath"
         "strings"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 type bondingCollector struct {
         slaves, active typedDesc
+        logger         log.Logger
 }
 
 func init() {
@@ -36,7 +38,7 @@ func init() {
 
 // NewBondingCollector returns a newly allocated bondingCollector.
 // It exposes the number of configured and active slave of linux bonding interfaces.
-func NewBondingCollector() (Collector, error) {
+func NewBondingCollector(logger log.Logger) (Collector, error) {
         return &bondingCollector{
                 slaves: typedDesc{prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, "bonding", "slaves"),
@@ -48,6 +50,7 @@ func NewBondingCollector() (Collector, error) {
                         "Number of active slaves per bonding interface.",
                         []string{"master"}, nil,
                 ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
@@ -57,7 +60,7 @@ func (c *bondingCollector) Update(ch chan<- prometheus.Metric) error {
         bondingStats, err := readBondingStats(statusfile)
         if err != nil {
                 if os.IsNotExist(err) {
-                        log.Debugf("Not collecting bonding, file does not exist: %s", statusfile)
+                        level.Debug(c.logger).Log("msg", "Not collecting bonding, file does not exist", "file", statusfile)
                         return nil
                 }
                 return err
diff --git a/collector/boot_time_bsd.go b/collector/boot_time_bsd.go
index cc2e895..74d4bce 100644
--- a/collector/boot_time_bsd.go
+++ b/collector/boot_time_bsd.go
@@ -17,17 +17,21 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
-type bootTimeCollector struct{ boottime bsdSysctl }
+type bootTimeCollector struct {
+        boottime bsdSysctl
+        logger   log.Logger
+}
 
 func init() {
         registerCollector("boottime", defaultEnabled, newBootTimeCollector)
 }
 
 // newBootTimeCollector returns a new Collector exposing system boot time on BSD systems.
-func newBootTimeCollector() (Collector, error) {
+func newBootTimeCollector(logger log.Logger) (Collector, error) {
         return &bootTimeCollector{
                 boottime: bsdSysctl{
                         name:        "boot_time_seconds",
@@ -35,6 +39,7 @@ func newBootTimeCollector() (Collector, error) {
                         mib:         "kern.boottime",
                         dataType:    bsdSysctlTypeStructTimeval,
                 },
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/boot_time_solaris.go b/collector/boot_time_solaris.go
index ea0c50a..eb27034 100644
--- a/collector/boot_time_solaris.go
+++ b/collector/boot_time_solaris.go
@@ -17,19 +17,21 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/siebenmann/go-kstat"
 )
 
 type bootTimeCollector struct {
         boottime typedDesc
+        logger   log.Logger
 }
 
 func init() {
         registerCollector("boottime", defaultEnabled, newBootTimeCollector)
 }
 
-func newBootTimeCollector() (Collector, error) {
+func newBootTimeCollector(logger log.Logger) (Collector, error) {
         return &bootTimeCollector{
                 boottime: typedDesc{
                         prometheus.NewDesc(
@@ -37,6 +39,7 @@ func newBootTimeCollector() (Collector, error) {
                                 "Unix time of last boot, including microseconds.",
                                 nil, nil,
                         ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/buddyinfo.go b/collector/buddyinfo.go
index 316766e..e94e283 100644
--- a/collector/buddyinfo.go
+++ b/collector/buddyinfo.go
@@ -20,8 +20,9 @@ import (
         "fmt"
         "strconv"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
@@ -30,8 +31,9 @@ const (
 )
 
 type buddyinfoCollector struct {
-        fs   procfs.FS
-        desc *prometheus.Desc
+        fs     procfs.FS
+        desc   *prometheus.Desc
+        logger log.Logger
 }
 
 func init() {
@@ -39,7 +41,7 @@ func init() {
 }
 
 // NewBuddyinfoCollector returns a new Collector exposing buddyinfo stats.
-func NewBuddyinfoCollector() (Collector, error) {
+func NewBuddyinfoCollector(logger log.Logger) (Collector, error) {
         desc := prometheus.NewDesc(
                 prometheus.BuildFQName(namespace, buddyInfoSubsystem, "blocks"),
                 "Count of free blocks according to size.",
@@ -49,7 +51,7 @@ func NewBuddyinfoCollector() (Collector, error) {
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
         }
-        return &buddyinfoCollector{fs, desc}, nil
+        return &buddyinfoCollector{fs, desc, logger}, nil
 }
 
 // Update calls (*buddyinfoCollector).getBuddyInfo to get the platform specific
@@ -60,7 +62,7 @@ func (c *buddyinfoCollector) Update(ch chan<- prometheus.Metric) error {
                 return fmt.Errorf("couldn't get buddyinfo: %s", err)
         }
 
-        log.Debugf("Set node_buddy: %#v", buddyInfo)
+        level.Debug(c.logger).Log("msg", "Set node_buddy", "buddyInfo", buddyInfo)
         for _, entry := range buddyInfo {
                 for size, value := range entry.Sizes {
                         ch <- prometheus.MustNewConstMetric(
diff --git a/collector/collector.go b/collector/collector.go
index 4b74b89..af8712c 100644
--- a/collector/collector.go
+++ b/collector/collector.go
@@ -19,8 +19,9 @@ import (
         "sync"
         "time"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -48,11 +49,11 @@ const (
 )
 
 var (
-        factories      = make(map[string]func() (Collector, error))
+        factories      = make(map[string]func(logger log.Logger) (Collector, error))
         collectorState = make(map[string]*bool)
 )
 
-func registerCollector(collector string, isDefaultEnabled bool, factory func() (Collector, error)) {
+func registerCollector(collector string, isDefaultEnabled bool, factory func(logger log.Logger) (Collector, error)) {
         var helpDefaultState string
         if isDefaultEnabled {
                 helpDefaultState = "enabled"
@@ -73,10 +74,11 @@ func registerCollector(collector string, isDefaultEnabled bool, factory func() (
 // NodeCollector implements the prometheus.Collector interface.
 type NodeCollector struct {
         Collectors map[string]Collector
+        logger     log.Logger
 }
 
 // NewNodeCollector creates a new NodeCollector.
-func NewNodeCollector(filters ...string) (*NodeCollector, error) {
+func NewNodeCollector(logger log.Logger, filters ...string) (*NodeCollector, error) {
         f := make(map[string]bool)
         for _, filter := range filters {
                 enabled, exist := collectorState[filter]
@@ -91,7 +93,7 @@ func NewNodeCollector(filters ...string) (*NodeCollector, error) {
         collectors := make(map[string]Collector)
         for key, enabled := range collectorState {
                 if *enabled {
-                        collector, err := factories[key]()
+                        collector, err := factories[key](log.With(logger, "collector", key))
                         if err != nil {
                                 return nil, err
                         }
@@ -100,7 +102,7 @@ func NewNodeCollector(filters ...string) (*NodeCollector, error) {
                         }
                 }
         }
-        return &NodeCollector{Collectors: collectors}, nil
+        return &NodeCollector{Collectors: collectors, logger: logger}, nil
 }
 
 // Describe implements the prometheus.Collector interface.
@@ -115,24 +117,24 @@ func (n NodeCollector) Collect(ch chan<- prometheus.Metric) {
         wg.Add(len(n.Collectors))
         for name, c := range n.Collectors {
                 go func(name string, c Collector) {
-                        execute(name, c, ch)
+                        execute(name, c, ch, n.logger)
                         wg.Done()
                 }(name, c)
         }
         wg.Wait()
 }
 
-func execute(name string, c Collector, ch chan<- prometheus.Metric) {
+func execute(name string, c Collector, ch chan<- prometheus.Metric, logger log.Logger) {
         begin := time.Now()
         err := c.Update(ch)
         duration := time.Since(begin)
         var success float64
 
         if err != nil {
-                log.Errorf("ERROR: %s collector failed after %fs: %s", name, duration.Seconds(), err)
+                level.Error(logger).Log("msg", "collector failed", "name", name, "duration_seconds", duration.Seconds(), "err", err)
                 success = 0
         } else {
-                log.Debugf("OK: %s collector succeeded after %fs.", name, duration.Seconds())
+                level.Debug(logger).Log("msg", "collector succeeded", "name", name, "duration_seconds", duration.Seconds())
                 success = 1
         }
         ch <- prometheus.MustNewConstMetric(scrapeDurationDesc, prometheus.GaugeValue, duration.Seconds(), name)
diff --git a/collector/conntrack_linux.go b/collector/conntrack_linux.go
index 4a0e375..9dc8114 100644
--- a/collector/conntrack_linux.go
+++ b/collector/conntrack_linux.go
@@ -16,12 +16,14 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
 type conntrackCollector struct {
         current *prometheus.Desc
         limit   *prometheus.Desc
+        logger  log.Logger
 }
 
 func init() {
@@ -29,7 +31,7 @@ func init() {
 }
 
 // NewConntrackCollector returns a new Collector exposing conntrack stats.
-func NewConntrackCollector() (Collector, error) {
+func NewConntrackCollector(logger log.Logger) (Collector, error) {
         return &conntrackCollector{
                 current: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, "", "nf_conntrack_entries"),
@@ -41,6 +43,7 @@ func NewConntrackCollector() (Collector, error) {
                         "Maximum size of connection tracking table.",
                         nil, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/cpu_darwin.go b/collector/cpu_darwin.go
index 74afafd..ba4ba80 100644
--- a/collector/cpu_darwin.go
+++ b/collector/cpu_darwin.go
@@ -25,6 +25,7 @@ import (
         "strconv"
         "unsafe"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -49,7 +50,8 @@ import "C"
 const ClocksPerSec = float64(C.CLK_TCK)
 
 type statCollector struct {
-        cpu *prometheus.Desc
+        cpu    *prometheus.Desc
+        logger log.Logger
 }
 
 func init() {
@@ -57,9 +59,10 @@ func init() {
 }
 
 // NewCPUCollector returns a new Collector exposing CPU stats.
-func NewCPUCollector() (Collector, error) {
+func NewCPUCollector(logger log.Logger) (Collector, error) {
         return &statCollector{
-                cpu: nodeCPUSecondsDesc,
+                cpu:    nodeCPUSecondsDesc,
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/cpu_dragonfly.go b/collector/cpu_dragonfly.go
index b8c4c06..beef390 100644
--- a/collector/cpu_dragonfly.go
+++ b/collector/cpu_dragonfly.go
@@ -20,6 +20,7 @@ import (
         "fmt"
         "unsafe"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -75,7 +76,8 @@ import "C"
 const maxCPUTimesLen = C.MAXCPU * C.CPUSTATES
 
 type statCollector struct {
-        cpu *prometheus.Desc
+        cpu    *prometheus.Desc
+        logger log.Logger
 }
 
 func init() {
@@ -83,9 +85,10 @@ func init() {
 }
 
 // NewStatCollector returns a new Collector exposing CPU stats.
-func NewStatCollector() (Collector, error) {
+func NewStatCollector(logger log.Logger) (Collector, error) {
         return &statCollector{
-                cpu: nodeCPUSecondsDesc,
+                cpu:    nodeCPUSecondsDesc,
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/cpu_freebsd.go b/collector/cpu_freebsd.go
index dc3d6a1..41573e4 100644
--- a/collector/cpu_freebsd.go
+++ b/collector/cpu_freebsd.go
@@ -21,8 +21,9 @@ import (
         "strconv"
         "unsafe"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "golang.org/x/sys/unix"
 )
 
@@ -81,8 +82,9 @@ func getCPUTimes() ([]cputime, error) {
 }
 
 type statCollector struct {
-        cpu  typedDesc
-        temp typedDesc
+        cpu    typedDesc
+        temp   typedDesc
+        logger log.Logger
 }
 
 func init() {
@@ -90,7 +92,7 @@ func init() {
 }
 
 // NewStatCollector returns a new Collector exposing CPU stats.
-func NewStatCollector() (Collector, error) {
+func NewStatCollector(logger log.Logger) (Collector, error) {
         return &statCollector{
                 cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
                 temp: typedDesc{prometheus.NewDesc(
@@ -98,6 +100,7 @@ func NewStatCollector() (Collector, error) {
                         "CPU temperature",
                         []string{"cpu"}, nil,
                 ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
@@ -130,11 +133,11 @@ func (c *statCollector) Update(ch chan<- prometheus.Metric) error {
                 if err != nil {
                         if err == unix.ENOENT {
                                 // No temperature information for this CPU
-                                log.Debugf("no temperature information for CPU %d", cpu)
+                                level.Debug(c.logger).Log("msg", "no temperature information for CPU", "cpu", cpu)
                         } else {
                                 // Unexpected error
                                 ch <- c.temp.mustNewConstMetric(math.NaN(), lcpu)
-                                log.Errorf("failed to query CPU temperature for CPU %d: %s", cpu, err)
+                                level.Error(c.logger).Log("msg", "failed to query CPU temperature for CPU", "cpu", cpu, "err", err)
                         }
                         continue
                 }
diff --git a/collector/cpu_linux.go b/collector/cpu_linux.go
index c946520..1cb6f2c 100644
--- a/collector/cpu_linux.go
+++ b/collector/cpu_linux.go
@@ -20,10 +20,11 @@ import (
         "path/filepath"
         "strconv"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
-        kingpin "gopkg.in/alecthomas/kingpin.v2"
+        "gopkg.in/alecthomas/kingpin.v2"
 )
 
 type cpuCollector struct {
@@ -33,6 +34,7 @@ type cpuCollector struct {
         cpuGuest           *prometheus.Desc
         cpuCoreThrottle    *prometheus.Desc
         cpuPackageThrottle *prometheus.Desc
+        logger             log.Logger
 }
 
 var (
@@ -44,7 +46,7 @@ func init() {
 }
 
 // NewCPUCollector returns a new Collector exposing kernel/system statistics.
-func NewCPUCollector() (Collector, error) {
+func NewCPUCollector(logger log.Logger) (Collector, error) {
         fs, err := procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -72,6 +74,7 @@ func NewCPUCollector() (Collector, error) {
                         "Number of times this cpu package has been throttled.",
                         []string{"package"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
@@ -134,12 +137,12 @@ func (c *cpuCollector) updateThermalThrottle(ch chan<- prometheus.Metric) error
 
                 // topology/physical_package_id
                 if physicalPackageID, err = readUintFromFile(filepath.Join(cpu, "topology", "physical_package_id")); err != nil {
-                        log.Debugf("CPU %v is missing physical_package_id", cpu)
+                        level.Debug(c.logger).Log("msg", "CPU is missing physical_package_id", "cpu", cpu)
                         continue
                 }
                 // topology/core_id
                 if coreID, err = readUintFromFile(filepath.Join(cpu, "topology", "core_id")); err != nil {
-                        log.Debugf("CPU %v is missing core_id", cpu)
+                        level.Debug(c.logger).Log("msg", "CPU is missing core_id", "cpu", cpu)
                         continue
                 }
 
@@ -157,7 +160,7 @@ func (c *cpuCollector) updateThermalThrottle(ch chan<- prometheus.Metric) error
                         if coreThrottleCount, err := readUintFromFile(filepath.Join(cpu, "thermal_throttle", "core_throttle_count")); err == nil {
                                 packageCoreThrottles[physicalPackageID][coreID] = coreThrottleCount
                         } else {
-                                log.Debugf("CPU %v is missing core_throttle_count", cpu)
+                                level.Debug(c.logger).Log("msg", "CPU is missing core_throttle_count", "cpu", cpu)
                         }
                 }
 
@@ -167,7 +170,7 @@ func (c *cpuCollector) updateThermalThrottle(ch chan<- prometheus.Metric) error
                         if packageThrottleCount, err := readUintFromFile(filepath.Join(cpu, "thermal_throttle", "package_throttle_count")); err == nil {
                                 packageThrottles[physicalPackageID] = packageThrottleCount
                         } else {
-                                log.Debugf("CPU %v is missing package_throttle_count", cpu)
+                                level.Debug(c.logger).Log("msg", "CPU is missing package_throttle_count", "cpu", cpu)
                         }
                 }
         }
diff --git a/collector/cpu_openbsd.go b/collector/cpu_openbsd.go
index cddc204..b7d7688 100644
--- a/collector/cpu_openbsd.go
+++ b/collector/cpu_openbsd.go
@@ -19,6 +19,7 @@ import (
         "strconv"
         "unsafe"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "golang.org/x/sys/unix"
 )
@@ -30,16 +31,18 @@ import (
 import "C"
 
 type cpuCollector struct {
-        cpu typedDesc
+        cpu    typedDesc
+        logger log.Logger
 }
 
 func init() {
         registerCollector("cpu", defaultEnabled, NewCPUCollector)
 }
 
-func NewCPUCollector() (Collector, error) {
+func NewCPUCollector(logger log.Logger) (Collector, error) {
         return &cpuCollector{
-                cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
+                cpu:    typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/cpu_solaris.go b/collector/cpu_solaris.go
index f772765..0624454 100644
--- a/collector/cpu_solaris.go
+++ b/collector/cpu_solaris.go
@@ -19,6 +19,7 @@ package collector
 import (
         "strconv"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         kstat "github.com/siebenmann/go-kstat"
 )
@@ -27,16 +28,18 @@ import (
 import "C"
 
 type cpuCollector struct {
-        cpu typedDesc
+        cpu    typedDesc
+        logger log.Logger
 }
 
 func init() {
         registerCollector("cpu", defaultEnabled, NewCpuCollector)
 }
 
-func NewCpuCollector() (Collector, error) {
+func NewCpuCollector(logger log.Logger) (Collector, error) {
         return &cpuCollector{
-                cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
+                cpu:    typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/cpufreq_linux.go b/collector/cpufreq_linux.go
index c4de4d5..aa32ad2 100644
--- a/collector/cpufreq_linux.go
+++ b/collector/cpufreq_linux.go
@@ -18,6 +18,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/sysfs"
 )
@@ -30,6 +31,7 @@ type cpuFreqCollector struct {
         scalingFreq    *prometheus.Desc
         scalingFreqMin *prometheus.Desc
         scalingFreqMax *prometheus.Desc
+        logger         log.Logger
 }
 
 func init() {
@@ -37,7 +39,7 @@ func init() {
 }
 
 // NewCPUFreqCollector returns a new Collector exposing kernel/system statistics.
-func NewCPUFreqCollector() (Collector, error) {
+func NewCPUFreqCollector(logger log.Logger) (Collector, error) {
         fs, err := sysfs.NewFS(*sysPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open sysfs: %w", err)
@@ -75,6 +77,7 @@ func NewCPUFreqCollector() (Collector, error) {
                         "Maximum scaled cpu thread frequency in hertz.",
                         []string{"cpu"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/cpufreq_solaris.go b/collector/cpufreq_solaris.go
index 77ac3ab..7c614ff 100644
--- a/collector/cpufreq_solaris.go
+++ b/collector/cpufreq_solaris.go
@@ -20,6 +20,7 @@ import (
         "fmt"
         "strconv"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         kstat "github.com/siebenmann/go-kstat"
 )
@@ -30,13 +31,14 @@ import "C"
 type cpuFreqCollector struct {
         cpuFreq    *prometheus.Desc
         cpuFreqMax *prometheus.Desc
+        logger     log.Logger
 }
 
 func init() {
         registerCollector("cpufreq", defaultEnabled, NewCpuFreqCollector)
 }
 
-func NewFreqCpuCollector() (Collector, error) {
+func NewFreqCpuCollector(logger log.Logger) (Collector, error) {
         return &cpuFreqCollector{
                 cpuFreq: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, cpuCollectorSubsystem, "frequency_hertz"),
@@ -48,6 +50,7 @@ func NewFreqCpuCollector() (Collector, error) {
                         "Maximum cpu thread frequency in hertz.",
                         []string{"cpu"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/devstat_dragonfly.go b/collector/devstat_dragonfly.go
index d2cc6cd..69e24ba 100644
--- a/collector/devstat_dragonfly.go
+++ b/collector/devstat_dragonfly.go
@@ -19,6 +19,7 @@ import (
         "errors"
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -96,6 +97,7 @@ type devstatCollector struct {
         bytesDesc     *prometheus.Desc
         transfersDesc *prometheus.Desc
         blocksDesc    *prometheus.Desc
+        logger        log.Logger
 }
 
 func init() {
@@ -103,7 +105,7 @@ func init() {
 }
 
 // NewDevstatCollector returns a new Collector exposing Device stats.
-func NewDevstatCollector() (Collector, error) {
+func NewDevstatCollector(logger log.Logger) (Collector, error) {
         return &devstatCollector{
                 bytesDesc: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, devstatSubsystem, "bytes_total"),
@@ -120,6 +122,7 @@ func NewDevstatCollector() (Collector, error) {
                         "The total number of bytes given in terms of the devices blocksize.",
                         []string{"device"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/devstat_freebsd.go b/collector/devstat_freebsd.go
index d394f34..dfa18d1 100644
--- a/collector/devstat_freebsd.go
+++ b/collector/devstat_freebsd.go
@@ -21,6 +21,7 @@ import (
         "sync"
         "unsafe"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -41,6 +42,7 @@ type devstatCollector struct {
         duration  typedDesc
         busyTime  typedDesc
         blocks    typedDesc
+        logger    log.Logger
 }
 
 func init() {
@@ -48,7 +50,7 @@ func init() {
 }
 
 // NewDevstatCollector returns a new Collector exposing Device stats.
-func NewDevstatCollector() (Collector, error) {
+func NewDevstatCollector(logger log.Logger) (Collector, error) {
         return &devstatCollector{
                 devinfo: &C.struct_devinfo{},
                 bytes: typedDesc{prometheus.NewDesc(
@@ -76,6 +78,7 @@ func NewDevstatCollector() (Collector, error) {
                         "The total number of blocks transferred.",
                         []string{"device"}, nil,
                 ), prometheus.CounterValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/diskstats_darwin.go b/collector/diskstats_darwin.go
index 2c76582..8b11812 100644
--- a/collector/diskstats_darwin.go
+++ b/collector/diskstats_darwin.go
@@ -18,6 +18,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/lufia/iostat"
         "github.com/prometheus/client_golang/prometheus"
 )
@@ -28,7 +29,8 @@ type typedDescFunc struct {
 }
 
 type diskstatsCollector struct {
-        descs []typedDescFunc
+        descs  []typedDescFunc
+        logger log.Logger
 }
 
 func init() {
@@ -36,7 +38,7 @@ func init() {
 }
 
 // NewDiskstatsCollector returns a new Collector exposing disk device stats.
-func NewDiskstatsCollector() (Collector, error) {
+func NewDiskstatsCollector(logger log.Logger) (Collector, error) {
         var diskLabelNames = []string{"device"}
 
         return &diskstatsCollector{
@@ -124,6 +126,7 @@ func NewDiskstatsCollector() (Collector, error) {
                                 },
                         },
                 },
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/diskstats_linux.go b/collector/diskstats_linux.go
index 32bb90c..5d71422 100644
--- a/collector/diskstats_linux.go
+++ b/collector/diskstats_linux.go
@@ -24,8 +24,9 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -54,6 +55,7 @@ func (d *typedFactorDesc) mustNewConstMetric(value float64, labels ...string) pr
 type diskstatsCollector struct {
         ignoredDevicesPattern *regexp.Regexp
         descs                 []typedFactorDesc
+        logger                log.Logger
 }
 
 func init() {
@@ -62,7 +64,7 @@ func init() {
 
 // NewDiskstatsCollector returns a new Collector exposing disk device stats.
 // Docs from https://www.kernel.org/doc/Documentation/iostats.txt
-func NewDiskstatsCollector() (Collector, error) {
+func NewDiskstatsCollector(logger log.Logger) (Collector, error) {
         var diskLabelNames = []string{"device"}
 
         return &diskstatsCollector{
@@ -178,6 +180,7 @@ func NewDiskstatsCollector() (Collector, error) {
                                 factor: .001,
                         },
                 },
+                logger: logger,
         }, nil
 }
 
@@ -189,7 +192,7 @@ func (c *diskstatsCollector) Update(ch chan<- prometheus.Metric) error {
 
         for dev, stats := range diskStats {
                 if c.ignoredDevicesPattern.MatchString(dev) {
-                        log.Debugf("Ignoring device: %s", dev)
+                        level.Debug(c.logger).Log("msg", "Ignoring device", "device", dev)
                         continue
                 }
 
diff --git a/collector/diskstats_openbsd.go b/collector/diskstats_openbsd.go
index f17e2a8..3385f37 100644
--- a/collector/diskstats_openbsd.go
+++ b/collector/diskstats_openbsd.go
@@ -18,6 +18,7 @@ package collector
 import (
         "unsafe"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "golang.org/x/sys/unix"
 )
@@ -34,6 +35,7 @@ type diskstatsCollector struct {
         wxfer  typedDesc
         wbytes typedDesc
         time   typedDesc
+        logger log.Logger
 }
 
 func init() {
@@ -41,13 +43,14 @@ func init() {
 }
 
 // NewDiskstatsCollector returns a new Collector exposing disk device stats.
-func NewDiskstatsCollector() (Collector, error) {
+func NewDiskstatsCollector(logger log.Logger) (Collector, error) {
         return &diskstatsCollector{
                 rxfer:  typedDesc{readsCompletedDesc, prometheus.CounterValue},
                 rbytes: typedDesc{readBytesDesc, prometheus.CounterValue},
                 wxfer:  typedDesc{writesCompletedDesc, prometheus.CounterValue},
                 wbytes: typedDesc{writtenBytesDesc, prometheus.CounterValue},
                 time:   typedDesc{ioTimeSecondsDesc, prometheus.CounterValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/drbd_linux.go b/collector/drbd_linux.go
index 521f2e2..5a340b9 100644
--- a/collector/drbd_linux.go
+++ b/collector/drbd_linux.go
@@ -20,8 +20,9 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 // Numerical metric provided by /proc/drbd.
@@ -74,13 +75,14 @@ type drbdCollector struct {
         numerical  map[string]drbdNumericalMetric
         stringPair map[string]drbdStringPairMetric
         connected  *prometheus.Desc
+        logger     log.Logger
 }
 
 func init() {
         registerCollector("drbd", defaultDisabled, newDRBDCollector)
 }
 
-func newDRBDCollector() (Collector, error) {
+func newDRBDCollector(logger log.Logger) (Collector, error) {
         return &drbdCollector{
                 numerical: map[string]drbdNumericalMetric{
                         "ns": newDRBDNumericalMetric(
@@ -176,6 +178,7 @@ func newDRBDCollector() (Collector, error) {
                         []string{"device"},
                         nil,
                 ),
+                logger: logger,
         }, nil
 }
 
@@ -184,7 +187,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
         file, err := os.Open(statsFile)
         if err != nil {
                 if os.IsNotExist(err) {
-                        log.Debugf("drbd: %s does not exist, skipping: %s", statsFile, err)
+                        level.Debug(c.logger).Log("msg", "stats file does not exist, skipping", "file", statsFile, "err", err)
                         return nil
                 }
 
@@ -201,7 +204,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
 
                 kv := strings.Split(field, ":")
                 if len(kv) != 2 {
-                        log.Debugf("drbd: skipping invalid key:value pair %q", field)
+                        level.Debug(c.logger).Log("msg", "skipping invalid key:value pair", "field", field)
                         continue
                 }
 
@@ -267,7 +270,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
                         continue
                 }
 
-                log.Debugf("drbd: unhandled key-value pair: [%s: %q]", kv[0], kv[1])
+                level.Debug(c.logger).Log("msg", "unhandled key-value pair", "key", kv[0], "value", kv[1])
         }
 
         return scanner.Err()
diff --git a/collector/edac_linux.go b/collector/edac_linux.go
index de33873..91b9510 100644
--- a/collector/edac_linux.go
+++ b/collector/edac_linux.go
@@ -20,6 +20,7 @@ import (
         "path/filepath"
         "regexp"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -37,6 +38,7 @@ type edacCollector struct {
         ueCount      *prometheus.Desc
         csRowCECount *prometheus.Desc
         csRowUECount *prometheus.Desc
+        logger       log.Logger
 }
 
 func init() {
@@ -44,7 +46,7 @@ func init() {
 }
 
 // NewEdacCollector returns a new Collector exposing edac stats.
-func NewEdacCollector() (Collector, error) {
+func NewEdacCollector(logger log.Logger) (Collector, error) {
         return &edacCollector{
                 ceCount: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, edacSubsystem, "correctable_errors_total"),
@@ -66,6 +68,7 @@ func NewEdacCollector() (Collector, error) {
                         "Total uncorrectable memory errors for this csrow.",
                         []string{"controller", "csrow"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/entropy_linux.go b/collector/entropy_linux.go
index 455615b..e68eb95 100644
--- a/collector/entropy_linux.go
+++ b/collector/entropy_linux.go
@@ -18,11 +18,13 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
 type entropyCollector struct {
         entropyAvail *prometheus.Desc
+        logger       log.Logger
 }
 
 func init() {
@@ -30,13 +32,14 @@ func init() {
 }
 
 // NewEntropyCollector returns a new Collector exposing entropy stats.
-func NewEntropyCollector() (Collector, error) {
+func NewEntropyCollector(logger log.Logger) (Collector, error) {
         return &entropyCollector{
                 entropyAvail: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, "", "entropy_available_bits"),
                         "Bits of available entropy.",
                         nil, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/exec_bsd.go b/collector/exec_bsd.go
index e4b780b..c7bcb74 100644
--- a/collector/exec_bsd.go
+++ b/collector/exec_bsd.go
@@ -17,11 +17,13 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
 type execCollector struct {
         sysctls []bsdSysctl
+        logger  log.Logger
 }
 
 func init() {
@@ -29,7 +31,7 @@ func init() {
 }
 
 // NewExecCollector returns a new Collector exposing system execution statistics.
-func NewExecCollector() (Collector, error) {
+func NewExecCollector(logger log.Logger) (Collector, error) {
         // From sys/vm/vm_meter.c:
         // All are of type CTLTYPE_UINT.
         //
@@ -73,6 +75,7 @@ func NewExecCollector() (Collector, error) {
                                 mib:         "vm.stats.vm.v_forks",
                         },
                 },
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/filefd_linux.go b/collector/filefd_linux.go
index 1d34889..f8d3fce 100644
--- a/collector/filefd_linux.go
+++ b/collector/filefd_linux.go
@@ -22,6 +22,7 @@ import (
         "os"
         "strconv"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -29,15 +30,17 @@ const (
         fileFDStatSubsystem = "filefd"
 )
 
-type fileFDStatCollector struct{}
+type fileFDStatCollector struct {
+        logger log.Logger
+}
 
 func init() {
         registerCollector(fileFDStatSubsystem, defaultEnabled, NewFileFDStatCollector)
 }
 
 // NewFileFDStatCollector returns a new Collector exposing file-nr stats.
-func NewFileFDStatCollector() (Collector, error) {
-        return &fileFDStatCollector{}, nil
+func NewFileFDStatCollector(logger log.Logger) (Collector, error) {
+        return &fileFDStatCollector{logger}, nil
 }
 
 func (c *fileFDStatCollector) Update(ch chan<- prometheus.Metric) error {
diff --git a/collector/filesystem_bsd.go b/collector/filesystem_bsd.go
index b9aa1cc..7b30904 100644
--- a/collector/filesystem_bsd.go
+++ b/collector/filesystem_bsd.go
@@ -20,7 +20,7 @@ import (
         "errors"
         "unsafe"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log/level"
 )
 
 /*
@@ -50,14 +50,14 @@ func (c *filesystemCollector) GetStats() (stats []filesystemStats, err error) {
         for i := 0; i < int(count); i++ {
                 mountpoint := C.GoString(&mnt[i].f_mntonname[0])
                 if c.ignoredMountPointsPattern.MatchString(mountpoint) {
-                        log.Debugf("Ignoring mount point: %s", mountpoint)
+                        level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", mountpoint)
                         continue
                 }
 
                 device := C.GoString(&mnt[i].f_mntfromname[0])
                 fstype := C.GoString(&mnt[i].f_fstypename[0])
                 if c.ignoredFSTypesPattern.MatchString(fstype) {
-                        log.Debugf("Ignoring fs type: %s", fstype)
+                        level.Debug(c.logger).Log("msg", "Ignoring fs type", "type", fstype)
                         continue
                 }
 
diff --git a/collector/filesystem_common.go b/collector/filesystem_common.go
index da4cecd..6971f44 100644
--- a/collector/filesystem_common.go
+++ b/collector/filesystem_common.go
@@ -19,6 +19,7 @@ package collector
 import (
         "regexp"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -48,6 +49,7 @@ type filesystemCollector struct {
         sizeDesc, freeDesc, availDesc *prometheus.Desc
         filesDesc, filesFreeDesc      *prometheus.Desc
         roDesc, deviceErrorDesc       *prometheus.Desc
+        logger                        log.Logger
 }
 
 type filesystemLabels struct {
@@ -66,7 +68,7 @@ func init() {
 }
 
 // NewFilesystemCollector returns a new Collector exposing filesystems stats.
-func NewFilesystemCollector() (Collector, error) {
+func NewFilesystemCollector(logger log.Logger) (Collector, error) {
         subsystem := "filesystem"
         mountPointPattern := regexp.MustCompile(*ignoredMountPoints)
         filesystemsTypesPattern := regexp.MustCompile(*ignoredFSTypes)
@@ -123,6 +125,7 @@ func NewFilesystemCollector() (Collector, error) {
                 filesFreeDesc:             filesFreeDesc,
                 roDesc:                    roDesc,
                 deviceErrorDesc:           deviceErrorDesc,
+                logger:                    logger,
         }, nil
 }
 
diff --git a/collector/filesystem_freebsd.go b/collector/filesystem_freebsd.go
index 47c4833..8fceba7 100644
--- a/collector/filesystem_freebsd.go
+++ b/collector/filesystem_freebsd.go
@@ -19,7 +19,7 @@ import (
         "bytes"
         "unsafe"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log/level"
         "golang.org/x/sys/unix"
 )
 
@@ -54,14 +54,14 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
         for _, fs := range buf {
                 mountpoint := gostring(fs.Mntonname[:])
                 if c.ignoredMountPointsPattern.MatchString(mountpoint) {
-                        log.Debugf("Ignoring mount point: %s", mountpoint)
+                        level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", mountpoint)
                         continue
                 }
 
                 device := gostring(fs.Mntfromname[:])
                 fstype := gostring(fs.Fstypename[:])
                 if c.ignoredFSTypesPattern.MatchString(fstype) {
-                        log.Debugf("Ignoring fs type: %s", fstype)
+                        level.Debug(c.logger).Log("msg", "Ignoring fs type", "type", fstype)
                         continue
                 }
 
diff --git a/collector/filesystem_linux.go b/collector/filesystem_linux.go
index 98e51b8..e83b27a 100644
--- a/collector/filesystem_linux.go
+++ b/collector/filesystem_linux.go
@@ -24,9 +24,10 @@ import (
         "sync"
         "time"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "golang.org/x/sys/unix"
-        kingpin "gopkg.in/alecthomas/kingpin.v2"
+        "gopkg.in/alecthomas/kingpin.v2"
 )
 
 const (
@@ -42,18 +43,18 @@ var stuckMountsMtx = &sync.Mutex{}
 
 // GetStats returns filesystem stats.
 func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
-        mps, err := mountPointDetails()
+        mps, err := mountPointDetails(c.logger)
         if err != nil {
                 return nil, err
         }
         stats := []filesystemStats{}
         for _, labels := range mps {
                 if c.ignoredMountPointsPattern.MatchString(labels.mountPoint) {
-                        log.Debugf("Ignoring mount point: %s", labels.mountPoint)
+                        level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", labels.mountPoint)
                         continue
                 }
                 if c.ignoredFSTypesPattern.MatchString(labels.fsType) {
-                        log.Debugf("Ignoring fs type: %s", labels.fsType)
+                        level.Debug(c.logger).Log("msg", "Ignoring fs", "type", labels.fsType)
                         continue
                 }
                 stuckMountsMtx.Lock()
@@ -62,7 +63,7 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
                                 labels:      labels,
                                 deviceError: 1,
                         })
-                        log.Debugf("Mount point %q is in an unresponsive state", labels.mountPoint)
+                        level.Debug(c.logger).Log("msg", "Mount point is in an unresponsive state", "mountpoint", labels.mountPoint)
                         stuckMountsMtx.Unlock()
                         continue
                 }
@@ -71,7 +72,7 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
                 // The success channel is used do tell the "watcher" that the stat
                 // finished successfully. The channel is closed on success.
                 success := make(chan struct{})
-                go stuckMountWatcher(labels.mountPoint, success)
+                go stuckMountWatcher(labels.mountPoint, success, c.logger)
 
                 buf := new(unix.Statfs_t)
                 err = unix.Statfs(rootfsFilePath(labels.mountPoint), buf)
@@ -79,7 +80,7 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
                 close(success)
                 // If the mount has been marked as stuck, unmark it and log it's recovery.
                 if _, ok := stuckMounts[labels.mountPoint]; ok {
-                        log.Debugf("Mount point %q has recovered, monitoring will resume", labels.mountPoint)
+                        level.Debug(c.logger).Log("msg", "Mount point has recovered, monitoring will resume", "mountpoint", labels.mountPoint)
                         delete(stuckMounts, labels.mountPoint)
                 }
                 stuckMountsMtx.Unlock()
@@ -89,7 +90,8 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
                                 labels:      labels,
                                 deviceError: 1,
                         })
-                        log.Debugf("Error on statfs() system call for %q: %s", rootfsFilePath(labels.mountPoint), err)
+
+                        level.Debug(c.logger).Log("msg", "Error on statfs() system call", "rootfs", rootfsFilePath(labels.mountPoint), "err", err)
                         continue
                 }
 
@@ -117,7 +119,7 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
 // stuckMountWatcher listens on the given success channel and if the channel closes
 // then the watcher does nothing. If instead the timeout is reached, the
 // mount point that is being watched is marked as stuck.
-func stuckMountWatcher(mountPoint string, success chan struct{}) {
+func stuckMountWatcher(mountPoint string, success chan struct{}, logger log.Logger) {
         select {
         case <-success:
                 // Success
@@ -128,18 +130,18 @@ func stuckMountWatcher(mountPoint string, success chan struct{}) {
                 case <-success:
                         // Success came in just after the timeout was reached, don't label the mount as stuck
                 default:
-                        log.Debugf("Mount point %q timed out, it is being labeled as stuck and will not be monitored", mountPoint)
+                        level.Debug(logger).Log("msg", "Mount point timed out, it is being labeled as stuck and will not be monitored", "mountpoint", mountPoint)
                         stuckMounts[mountPoint] = struct{}{}
                 }
                 stuckMountsMtx.Unlock()
         }
 }
 
-func mountPointDetails() ([]filesystemLabels, error) {
+func mountPointDetails(logger log.Logger) ([]filesystemLabels, error) {
         file, err := os.Open(procFilePath("1/mounts"))
         if os.IsNotExist(err) {
                 // Fallback to `/proc/mounts` if `/proc/1/mounts` is missing due hidepid.
-                log.Debugf("Got %q reading root mounts, falling back to system mounts", err)
+                level.Debug(logger).Log("msg", "Reading root mounts failed, falling back to system mounts", "err", err)
                 file, err = os.Open(procFilePath("mounts"))
         }
         if err != nil {
diff --git a/collector/filesystem_linux_test.go b/collector/filesystem_linux_test.go
index 6271c19..973cd14 100644
--- a/collector/filesystem_linux_test.go
+++ b/collector/filesystem_linux_test.go
@@ -16,6 +16,7 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "strings"
         "testing"
 
@@ -80,7 +81,7 @@ func TestMountPointDetails(t *testing.T) {
                 "/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/[vsanDatastore]   bafb9e5a-8856-7e6c-699c-801844e77a4a/kubernetes-dynamic-pvc-3eba5bba-48a3-11e8-89ab-005056b92113.vmdk": "",
         }
 
-        filesystems, err := mountPointDetails()
+        filesystems, err := mountPointDetails(log.NewNopLogger())
         if err != nil {
                 t.Log(err)
         }
@@ -101,7 +102,7 @@ func TestMountsFallback(t *testing.T) {
                 "/": "",
         }
 
-        filesystems, err := mountPointDetails()
+        filesystems, err := mountPointDetails(log.NewNopLogger())
         if err != nil {
                 t.Log(err)
         }
@@ -129,7 +130,7 @@ func TestPathRootfs(t *testing.T) {
                 "/sys/fs/cgroup": "",
         }
 
-        filesystems, err := mountPointDetails()
+        filesystems, err := mountPointDetails(log.NewNopLogger())
         if err != nil {
                 t.Log(err)
         }
diff --git a/collector/hwmon_linux.go b/collector/hwmon_linux.go
index a6eb3b9..31dbd22 100644
--- a/collector/hwmon_linux.go
+++ b/collector/hwmon_linux.go
@@ -24,8 +24,9 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "golang.org/x/sys/unix"
 )
 
@@ -45,12 +46,14 @@ func init() {
         registerCollector("hwmon", defaultEnabled, NewHwMonCollector)
 }
 
-type hwMonCollector struct{}
+type hwMonCollector struct {
+        logger log.Logger
+}
 
 // NewHwMonCollector returns a new Collector exposing /sys/class/hwmon stats
 // (similar to lm-sensors).
-func NewHwMonCollector() (Collector, error) {
-        return &hwMonCollector{}, nil
+func NewHwMonCollector(logger log.Logger) (Collector, error) {
+        return &hwMonCollector{logger}, nil
 }
 
 func cleanMetricName(name string) string {
@@ -422,7 +425,7 @@ func (c *hwMonCollector) Update(ch chan<- prometheus.Metric) error {
         hwmonFiles, err := ioutil.ReadDir(hwmonPathName)
         if err != nil {
                 if os.IsNotExist(err) {
-                        log.Debug("hwmon collector metrics are not available for this system")
+                        level.Debug(c.logger).Log("msg", "hwmon collector metrics are not available for this system")
                         return nil
                 }
 
diff --git a/collector/infiniband_linux.go b/collector/infiniband_linux.go
index 52bf9a2..9d3ff60 100644
--- a/collector/infiniband_linux.go
+++ b/collector/infiniband_linux.go
@@ -20,6 +20,7 @@ import (
         "fmt"
         "strconv"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/sysfs"
 )
@@ -27,6 +28,7 @@ import (
 type infinibandCollector struct {
         fs          sysfs.FS
         metricDescs map[string]*prometheus.Desc
+        logger      log.Logger
 }
 
 func init() {
@@ -34,7 +36,7 @@ func init() {
 }
 
 // NewInfiniBandCollector returns a new Collector exposing InfiniBand stats.
-func NewInfiniBandCollector() (Collector, error) {
+func NewInfiniBandCollector(logger log.Logger) (Collector, error) {
         var i infinibandCollector
         var err error
 
@@ -42,6 +44,7 @@ func NewInfiniBandCollector() (Collector, error) {
         if err != nil {
                 return nil, fmt.Errorf("failed to open sysfs: %w", err)
         }
+        i.logger = logger
 
         // Detailed description for all metrics.
         descriptions := map[string]string{
diff --git a/collector/interrupts_common.go b/collector/interrupts_common.go
index 9e48829..e681cfc 100644
--- a/collector/interrupts_common.go
+++ b/collector/interrupts_common.go
@@ -16,10 +16,14 @@
 
 package collector
 
-import "github.com/prometheus/client_golang/prometheus"
+import (
+        "github.com/go-kit/kit/log"
+        "github.com/prometheus/client_golang/prometheus"
+)
 
 type interruptsCollector struct {
-        desc typedDesc
+        desc   typedDesc
+        logger log.Logger
 }
 
 func init() {
@@ -27,12 +31,13 @@ func init() {
 }
 
 // NewInterruptsCollector returns a new Collector exposing interrupts stats.
-func NewInterruptsCollector() (Collector, error) {
+func NewInterruptsCollector(logger log.Logger) (Collector, error) {
         return &interruptsCollector{
                 desc: typedDesc{prometheus.NewDesc(
                         namespace+"_interrupts_total",
                         "Interrupt details.",
                         interruptLabelNames, nil,
                 ), prometheus.CounterValue},
+                logger: logger,
         }, nil
 }
diff --git a/collector/ipvs_linux.go b/collector/ipvs_linux.go
index 6ac48b1..89469e5 100644
--- a/collector/ipvs_linux.go
+++ b/collector/ipvs_linux.go
@@ -20,8 +20,9 @@ import (
         "os"
         "strconv"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
@@ -30,6 +31,7 @@ type ipvsCollector struct {
         fs                                                                          procfs.FS
         backendConnectionsActive, backendConnectionsInact, backendWeight            typedDesc
         connections, incomingPackets, outgoingPackets, incomingBytes, outgoingBytes typedDesc
+        logger                                                                      log.Logger
 }
 
 func init() {
@@ -38,11 +40,11 @@ func init() {
 
 // NewIPVSCollector sets up a new collector for IPVS metrics. It accepts the
 // "procfs" config parameter to override the default proc location (/proc).
-func NewIPVSCollector() (Collector, error) {
-        return newIPVSCollector()
+func NewIPVSCollector(logger log.Logger) (Collector, error) {
+        return newIPVSCollector(logger)
 }
 
-func newIPVSCollector() (*ipvsCollector, error) {
+func newIPVSCollector(logger log.Logger) (*ipvsCollector, error) {
         var (
                 ipvsBackendLabelNames = []string{
                         "local_address",
@@ -57,6 +59,7 @@ func newIPVSCollector() (*ipvsCollector, error) {
                 subsystem = "ipvs"
         )
 
+        c.logger = logger
         c.fs, err = procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -111,7 +114,7 @@ func (c *ipvsCollector) Update(ch chan<- prometheus.Metric) error {
         if err != nil {
                 // Cannot access ipvs metrics, report no error.
                 if os.IsNotExist(err) {
-                        log.Debug("ipvs collector metrics are not available for this system")
+                        level.Debug(c.logger).Log("msg", "ipvs collector metrics are not available for this system")
                         return nil
                 }
                 return fmt.Errorf("could not get IPVS stats: %s", err)
diff --git a/collector/ipvs_linux_test.go b/collector/ipvs_linux_test.go
index 5cb934a..a1c0cba 100644
--- a/collector/ipvs_linux_test.go
+++ b/collector/ipvs_linux_test.go
@@ -15,6 +15,7 @@ package collector
 
 import (
         "fmt"
+        "github.com/go-kit/kit/log"
         "io/ioutil"
         "net/http"
         "net/http/httptest"
@@ -30,7 +31,7 @@ func TestIPVSCollector(t *testing.T) {
         if _, err := kingpin.CommandLine.Parse([]string{"--path.procfs", "fixtures/proc"}); err != nil {
                 t.Fatal(err)
         }
-        collector, err := newIPVSCollector()
+        collector, err := newIPVSCollector(log.NewNopLogger())
         if err != nil {
                 t.Fatal(err)
         }
@@ -79,7 +80,7 @@ func TestIPVSCollectorResponse(t *testing.T) {
         if _, err := kingpin.CommandLine.Parse([]string{"--path.procfs", "fixtures/proc"}); err != nil {
                 t.Fatal(err)
         }
-        collector, err := NewIPVSCollector()
+        collector, err := NewIPVSCollector(log.NewNopLogger())
         if err != nil {
                 t.Fatal(err)
         }
diff --git a/collector/ksmd_linux.go b/collector/ksmd_linux.go
index 857664f..44d6f8d 100644
--- a/collector/ksmd_linux.go
+++ b/collector/ksmd_linux.go
@@ -19,6 +19,7 @@ import (
         "fmt"
         "path/filepath"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -29,6 +30,7 @@ var (
 
 type ksmdCollector struct {
         metricDescs map[string]*prometheus.Desc
+        logger      log.Logger
 }
 
 func init() {
@@ -47,7 +49,7 @@ func getCanonicalMetricName(filename string) string {
 }
 
 // NewKsmdCollector returns a new Collector exposing kernel/system statistics.
-func NewKsmdCollector() (Collector, error) {
+func NewKsmdCollector(logger log.Logger) (Collector, error) {
         subsystem := "ksmd"
         descs := make(map[string]*prometheus.Desc)
 
@@ -56,7 +58,7 @@ func NewKsmdCollector() (Collector, error) {
                         prometheus.BuildFQName(namespace, subsystem, getCanonicalMetricName(n)),
                         fmt.Sprintf("ksmd '%s' file.", n), nil, nil)
         }
-        return &ksmdCollector{descs}, nil
+        return &ksmdCollector{descs, logger}, nil
 }
 
 // Update implements Collector and exposes kernel and system statistics.
diff --git a/collector/loadavg.go b/collector/loadavg.go
index 5568faa..7c8bcff 100644
--- a/collector/loadavg.go
+++ b/collector/loadavg.go
@@ -19,12 +19,14 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 type loadavgCollector struct {
         metric []typedDesc
+        logger log.Logger
 }
 
 func init() {
@@ -32,13 +34,14 @@ func init() {
 }
 
 // NewLoadavgCollector returns a new Collector exposing load average stats.
-func NewLoadavgCollector() (Collector, error) {
+func NewLoadavgCollector(logger log.Logger) (Collector, error) {
         return &loadavgCollector{
                 metric: []typedDesc{
                         {prometheus.NewDesc(namespace+"_load1", "1m load average.", nil, nil), prometheus.GaugeValue},
                         {prometheus.NewDesc(namespace+"_load5", "5m load average.", nil, nil), prometheus.GaugeValue},
                         {prometheus.NewDesc(namespace+"_load15", "15m load average.", nil, nil), prometheus.GaugeValue},
                 },
+                logger: logger,
         }, nil
 }
 
@@ -48,7 +51,7 @@ func (c *loadavgCollector) Update(ch chan<- prometheus.Metric) error {
                 return fmt.Errorf("couldn't get load: %s", err)
         }
         for i, load := range loads {
-                log.Debugf("return load %d: %f", i, load)
+                level.Debug(c.logger).Log("msg", "return load", "index", i, "load", load)
                 ch <- c.metric[i].mustNewConstMetric(load)
         }
         return err
diff --git a/collector/logind_linux.go b/collector/logind_linux.go
index ba23f11..fb3cb57 100644
--- a/collector/logind_linux.go
+++ b/collector/logind_linux.go
@@ -20,6 +20,7 @@ import (
         "os"
         "strconv"
 
+        "github.com/go-kit/kit/log"
         "github.com/godbus/dbus"
         "github.com/prometheus/client_golang/prometheus"
 )
@@ -43,7 +44,9 @@ var (
         )
 )
 
-type logindCollector struct{}
+type logindCollector struct {
+        logger log.Logger
+}
 
 type logindDbus struct {
         conn   *dbus.Conn
@@ -82,8 +85,8 @@ func init() {
 }
 
 // NewLogindCollector returns a new Collector exposing logind statistics.
-func NewLogindCollector() (Collector, error) {
-        return &logindCollector{}, nil
+func NewLogindCollector(logger log.Logger) (Collector, error) {
+        return &logindCollector{logger}, nil
 }
 
 func (lc *logindCollector) Update(ch chan<- prometheus.Metric) error {
diff --git a/collector/mdadm_linux.go b/collector/mdadm_linux.go
index aced6cd..faf1cee 100644
--- a/collector/mdadm_linux.go
+++ b/collector/mdadm_linux.go
@@ -19,20 +19,23 @@ import (
         "fmt"
         "os"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
-type mdadmCollector struct{}
+type mdadmCollector struct {
+        logger log.Logger
+}
 
 func init() {
         registerCollector("mdadm", defaultEnabled, NewMdadmCollector)
 }
 
 // NewMdadmCollector returns a new Collector exposing raid statistics.
-func NewMdadmCollector() (Collector, error) {
-        return &mdadmCollector{}, nil
+func NewMdadmCollector(logger log.Logger) (Collector, error) {
+        return &mdadmCollector{logger}, nil
 }
 
 var (
@@ -101,7 +104,7 @@ func (c *mdadmCollector) Update(ch chan<- prometheus.Metric) error {
 
         if err != nil {
                 if os.IsNotExist(err) {
-                        log.Debugf("Not collecting mdstat, file does not exist: %s", *procPath)
+                        level.Debug(c.logger).Log("msg", "Not collecting mdstat, file does not exist", "file", *procPath)
                         return nil
                 }
 
@@ -109,7 +112,7 @@ func (c *mdadmCollector) Update(ch chan<- prometheus.Metric) error {
         }
 
         for _, mdStat := range mdStats {
-                log.Debugf("collecting metrics for device %s", mdStat.Name)
+                level.Debug(c.logger).Log("msg", "collecting metrics for device", "device", mdStat.Name)
 
                 stateVals := make(map[string]float64)
                 stateVals[mdStat.ActivityState] = 1
diff --git a/collector/meminfo.go b/collector/meminfo.go
index 1652b8b..d3d3b8d 100644
--- a/collector/meminfo.go
+++ b/collector/meminfo.go
@@ -20,23 +20,26 @@ import (
         "fmt"
         "strings"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 const (
         memInfoSubsystem = "memory"
 )
 
-type meminfoCollector struct{}
+type meminfoCollector struct {
+        logger log.Logger
+}
 
 func init() {
         registerCollector("meminfo", defaultEnabled, NewMeminfoCollector)
 }
 
 // NewMeminfoCollector returns a new Collector exposing memory stats.
-func NewMeminfoCollector() (Collector, error) {
-        return &meminfoCollector{}, nil
+func NewMeminfoCollector(logger log.Logger) (Collector, error) {
+        return &meminfoCollector{logger}, nil
 }
 
 // Update calls (*meminfoCollector).getMemInfo to get the platform specific
@@ -47,7 +50,7 @@ func (c *meminfoCollector) Update(ch chan<- prometheus.Metric) error {
         if err != nil {
                 return fmt.Errorf("couldn't get meminfo: %s", err)
         }
-        log.Debugf("Set node_mem: %#v", memInfo)
+        level.Debug(c.logger).Log("msg", "Set node_mem", "memInfo", memInfo)
         for k, v := range memInfo {
                 if strings.HasSuffix(k, "_total") {
                         metricType = prometheus.CounterValue
diff --git a/collector/meminfo_numa_linux.go b/collector/meminfo_numa_linux.go
index 3d121bd..d36f6a0 100644
--- a/collector/meminfo_numa_linux.go
+++ b/collector/meminfo_numa_linux.go
@@ -25,6 +25,7 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -43,6 +44,7 @@ type meminfoMetric struct {
 
 type meminfoNumaCollector struct {
         metricDescs map[string]*prometheus.Desc
+        logger      log.Logger
 }
 
 func init() {
@@ -50,9 +52,10 @@ func init() {
 }
 
 // NewMeminfoNumaCollector returns a new Collector exposing memory stats.
-func NewMeminfoNumaCollector() (Collector, error) {
+func NewMeminfoNumaCollector(logger log.Logger) (Collector, error) {
         return &meminfoNumaCollector{
                 metricDescs: map[string]*prometheus.Desc{},
+                logger:      logger,
         }, nil
 }
 
diff --git a/collector/memory_bsd.go b/collector/memory_bsd.go
index cc6bc08..4be5ddd 100644
--- a/collector/memory_bsd.go
+++ b/collector/memory_bsd.go
@@ -19,6 +19,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "golang.org/x/sys/unix"
 )
@@ -31,6 +32,7 @@ type memoryCollector struct {
         pageSize uint64
         sysctls  []bsdSysctl
         kvm      kvm
+        logger   log.Logger
 }
 
 func init() {
@@ -38,7 +40,7 @@ func init() {
 }
 
 // NewMemoryCollector returns a new Collector exposing memory stats.
-func NewMemoryCollector() (Collector, error) {
+func NewMemoryCollector(logger log.Logger) (Collector, error) {
         tmp32, err := unix.SysctlUint32("vm.stats.vm.v_page_size")
         if err != nil {
                 return nil, fmt.Errorf("sysctl(vm.stats.vm.v_page_size) failed: %s", err)
@@ -57,6 +59,7 @@ func NewMemoryCollector() (Collector, error) {
         }
 
         return &memoryCollector{
+                logger:   logger,
                 pageSize: uint64(tmp32),
                 sysctls: []bsdSysctl{
                         // Descriptions via: https://wiki.freebsd.org/Memory
diff --git a/collector/mountstats_linux.go b/collector/mountstats_linux.go
index eeb01b7..3fa1597 100644
--- a/collector/mountstats_linux.go
+++ b/collector/mountstats_linux.go
@@ -16,8 +16,9 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
@@ -91,6 +92,8 @@ type mountStatsCollector struct {
         NFSEventPNFSWriteTotal           *prometheus.Desc
 
         proc procfs.Proc
+
+        logger log.Logger
 }
 
 // used to uniquely identify an NFS mount to prevent duplicates
@@ -105,7 +108,7 @@ func init() {
 }
 
 // NewMountStatsCollector returns a new Collector exposing NFS statistics.
-func NewMountStatsCollector() (Collector, error) {
+func NewMountStatsCollector(logger log.Logger) (Collector, error) {
         fs, err := procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -498,7 +501,8 @@ func NewMountStatsCollector() (Collector, error) {
                         nil,
                 ),
 
-                proc: proc,
+                proc:   proc,
+                logger: logger,
         }, nil
 }
 
@@ -534,7 +538,7 @@ func (c *mountStatsCollector) Update(ch chan<- prometheus.Metric) error {
                 deviceIdentifier := nfsDeviceIdentifier{m.Device, stats.Transport.Protocol, mountAddress}
                 i := deviceList[deviceIdentifier]
                 if i {
-                        log.Debugf("Skipping duplicate device entry %q", deviceIdentifier)
+                        level.Debug(c.logger).Log("msg", "Skipping duplicate device entry", "device", deviceIdentifier)
                         continue
                 }
 
diff --git a/collector/netclass_linux.go b/collector/netclass_linux.go
index af4b487..8d8a984 100644
--- a/collector/netclass_linux.go
+++ b/collector/netclass_linux.go
@@ -20,9 +20,10 @@ import (
         "fmt"
         "regexp"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/sysfs"
-        kingpin "gopkg.in/alecthomas/kingpin.v2"
+        "gopkg.in/alecthomas/kingpin.v2"
 )
 
 var (
@@ -34,6 +35,7 @@ type netClassCollector struct {
         subsystem             string
         ignoredDevicesPattern *regexp.Regexp
         metricDescs           map[string]*prometheus.Desc
+        logger                log.Logger
 }
 
 func init() {
@@ -41,7 +43,7 @@ func init() {
 }
 
 // NewNetClassCollector returns a new Collector exposing network class stats.
-func NewNetClassCollector() (Collector, error) {
+func NewNetClassCollector(logger log.Logger) (Collector, error) {
         fs, err := sysfs.NewFS(*sysPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open sysfs: %w", err)
@@ -52,6 +54,7 @@ func NewNetClassCollector() (Collector, error) {
                 subsystem:             "network",
                 ignoredDevicesPattern: pattern,
                 metricDescs:           map[string]*prometheus.Desc{},
+                logger:                logger,
         }, nil
 }
 
diff --git a/collector/netdev_bsd.go b/collector/netdev_bsd.go
index 18eca22..8bed2e1 100644
--- a/collector/netdev_bsd.go
+++ b/collector/netdev_bsd.go
@@ -21,7 +21,8 @@ import (
         "regexp"
         "strconv"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
 )
 
 /*
@@ -34,7 +35,7 @@ import (
 */
 import "C"
 
-func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]map[string]string, error) {
+func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp, logger log.Logger) (map[string]map[string]string, error) {
         netDev := map[string]map[string]string{}
 
         var ifap, ifa *C.struct_ifaddrs
@@ -47,11 +48,11 @@ func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]ma
                 if ifa.ifa_addr.sa_family == C.AF_LINK {
                         dev := C.GoString(ifa.ifa_name)
                         if ignore != nil && ignore.MatchString(dev) {
-                                log.Debugf("Ignoring device: %s", dev)
+                                level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
                                 continue
                         }
                         if accept != nil && !accept.MatchString(dev) {
-                                log.Debugf("Ignoring device: %s", dev)
+                                level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
                                 continue
                         }
 
diff --git a/collector/netdev_common.go b/collector/netdev_common.go
index 0c11023..e634c90 100644
--- a/collector/netdev_common.go
+++ b/collector/netdev_common.go
@@ -22,6 +22,7 @@ import (
         "regexp"
         "strconv"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -36,6 +37,7 @@ type netDevCollector struct {
         ignoredDevicesPattern *regexp.Regexp
         acceptDevicesPattern  *regexp.Regexp
         metricDescs           map[string]*prometheus.Desc
+        logger                log.Logger
 }
 
 func init() {
@@ -43,7 +45,7 @@ func init() {
 }
 
 // NewNetDevCollector returns a new Collector exposing network device stats.
-func NewNetDevCollector() (Collector, error) {
+func NewNetDevCollector(logger log.Logger) (Collector, error) {
         if *netdevIgnoredDevices != "" && *netdevAcceptDevices != "" {
                 return nil, errors.New("device-blacklist & accept-devices are mutually exclusive")
         }
@@ -63,11 +65,12 @@ func NewNetDevCollector() (Collector, error) {
                 ignoredDevicesPattern: ignorePattern,
                 acceptDevicesPattern:  acceptPattern,
                 metricDescs:           map[string]*prometheus.Desc{},
+                logger:                logger,
         }, nil
 }
 
 func (c *netDevCollector) Update(ch chan<- prometheus.Metric) error {
-        netDev, err := getNetDevStats(c.ignoredDevicesPattern, c.acceptDevicesPattern)
+        netDev, err := getNetDevStats(c.ignoredDevicesPattern, c.acceptDevicesPattern, c.logger)
         if err != nil {
                 return fmt.Errorf("couldn't get netstats: %s", err)
         }
diff --git a/collector/netdev_darwin.go b/collector/netdev_darwin.go
index dd25963..4970853 100644
--- a/collector/netdev_darwin.go
+++ b/collector/netdev_darwin.go
@@ -23,11 +23,12 @@ import (
         "regexp"
         "strconv"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "golang.org/x/sys/unix"
 )
 
-func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]map[string]string, error) {
+func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp, logger log.Logger) (map[string]map[string]string, error) {
         netDev := map[string]map[string]string{}
 
         ifs, err := net.Interfaces()
@@ -38,16 +39,16 @@ func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]ma
         for _, iface := range ifs {
                 ifaceData, err := getIfaceData(iface.Index)
                 if err != nil {
-                        log.Debugf("failed to load data for interface %q: %v", iface.Name, err)
+                        level.Debug(logger).Log("msg", "failed to load data for interface", "device", iface.Name, "err", err)
                         continue
                 }
 
                 if ignore != nil && ignore.MatchString(iface.Name) {
-                        log.Debugf("Ignoring device: %s", iface.Name)
+                        level.Debug(logger).Log("msg", "Ignoring device", "device", iface.Name)
                         continue
                 }
                 if accept != nil && !accept.MatchString(iface.Name) {
-                        log.Debugf("Ignoring device: %s", iface.Name)
+                        level.Debug(logger).Log("msg", "Ignoring device", "device", iface.Name)
                         continue
                 }
 
diff --git a/collector/netdev_linux.go b/collector/netdev_linux.go
index a5c6163..1a4b5df 100644
--- a/collector/netdev_linux.go
+++ b/collector/netdev_linux.go
@@ -23,7 +23,8 @@ import (
         "regexp"
         "strings"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
 )
 
 var (
@@ -31,17 +32,17 @@ var (
         procNetDevFieldSep    = regexp.MustCompile(` +`)
 )
 
-func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]map[string]string, error) {
+func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp, logger log.Logger) (map[string]map[string]string, error) {
         file, err := os.Open(procFilePath("net/dev"))
         if err != nil {
                 return nil, err
         }
         defer file.Close()
 
-        return parseNetDevStats(file, ignore, accept)
+        return parseNetDevStats(file, ignore, accept, logger)
 }
 
-func parseNetDevStats(r io.Reader, ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]map[string]string, error) {
+func parseNetDevStats(r io.Reader, ignore *regexp.Regexp, accept *regexp.Regexp, logger log.Logger) (map[string]map[string]string, error) {
         scanner := bufio.NewScanner(r)
         scanner.Scan() // skip first header
         scanner.Scan()
@@ -65,11 +66,11 @@ func parseNetDevStats(r io.Reader, ignore *regexp.Regexp, accept *regexp.Regexp)
 
                 dev := parts[1]
                 if ignore != nil && ignore.MatchString(dev) {
-                        log.Debugf("Ignoring device: %s", dev)
+                        level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
                         continue
                 }
                 if accept != nil && !accept.MatchString(dev) {
-                        log.Debugf("Ignoring device: %s", dev)
+                        level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
                         continue
                 }
 
diff --git a/collector/netdev_linux_test.go b/collector/netdev_linux_test.go
index 163c87f..1c88d83 100644
--- a/collector/netdev_linux_test.go
+++ b/collector/netdev_linux_test.go
@@ -14,6 +14,7 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "os"
         "regexp"
         "testing"
@@ -26,7 +27,7 @@ func TestNetDevStatsIgnore(t *testing.T) {
         }
         defer file.Close()
 
-        netStats, err := parseNetDevStats(file, regexp.MustCompile("^veth"), nil)
+        netStats, err := parseNetDevStats(file, regexp.MustCompile("^veth"), nil, log.NewNopLogger())
         if err != nil {
                 t.Fatal(err)
         }
@@ -67,7 +68,7 @@ func TestNetDevStatsAccept(t *testing.T) {
         }
         defer file.Close()
 
-        netStats, err := parseNetDevStats(file, nil, regexp.MustCompile("^💩0$"))
+        netStats, err := parseNetDevStats(file, nil, regexp.MustCompile("^💩0$"), log.NewNopLogger())
         if err != nil {
                 t.Fatal(err)
         }
diff --git a/collector/netdev_openbsd.go b/collector/netdev_openbsd.go
index b080cbc..f7c9030 100644
--- a/collector/netdev_openbsd.go
+++ b/collector/netdev_openbsd.go
@@ -20,7 +20,8 @@ import (
         "regexp"
         "strconv"
 
-        "github.com/prometheus/common/log"
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
 )
 
 /*
@@ -31,7 +32,7 @@ import (
 */
 import "C"
 
-func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]map[string]string, error) {
+func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp, logger log.Logger) (map[string]map[string]string, error) {
         netDev := map[string]map[string]string{}
 
         var ifap, ifa *C.struct_ifaddrs
@@ -44,11 +45,11 @@ func getNetDevStats(ignore *regexp.Regexp, accept *regexp.Regexp) (map[string]ma
                 if ifa.ifa_addr.sa_family == C.AF_LINK {
                         dev := C.GoString(ifa.ifa_name)
                         if ignore != nil && ignore.MatchString(dev) {
-                                log.Debugf("Ignoring device: %s", dev)
+                                level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
                                 continue
                         }
                         if accept != nil && !accept.MatchString(dev) {
-                                log.Debugf("Ignoring device: %s", dev)
+                                level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
                                 continue
                         }
 
diff --git a/collector/netstat_linux.go b/collector/netstat_linux.go
index d5eed69..f0aca26 100644
--- a/collector/netstat_linux.go
+++ b/collector/netstat_linux.go
@@ -24,6 +24,7 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -38,6 +39,7 @@ var (
 
 type netStatCollector struct {
         fieldPattern *regexp.Regexp
+        logger       log.Logger
 }
 
 func init() {
@@ -46,10 +48,11 @@ func init() {
 
 // NewNetStatCollector takes and returns
 // a new Collector exposing network stats.
-func NewNetStatCollector() (Collector, error) {
+func NewNetStatCollector(logger log.Logger) (Collector, error) {
         pattern := regexp.MustCompile(*netStatFields)
         return &netStatCollector{
                 fieldPattern: pattern,
+                logger:       logger,
         }, nil
 }
 
diff --git a/collector/nfs_linux.go b/collector/nfs_linux.go
index 05b241e..7ed4930 100644
--- a/collector/nfs_linux.go
+++ b/collector/nfs_linux.go
@@ -18,8 +18,9 @@ import (
         "os"
         "reflect"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs/nfs"
 )
 
@@ -35,6 +36,7 @@ type nfsCollector struct {
         nfsRPCRetransmissionsDesc         *prometheus.Desc
         nfsRPCAuthenticationRefreshesDesc *prometheus.Desc
         nfsProceduresDesc                 *prometheus.Desc
+        logger                            log.Logger
 }
 
 func init() {
@@ -42,7 +44,7 @@ func init() {
 }
 
 // NewNfsCollector returns a new Collector exposing NFS statistics.
-func NewNfsCollector() (Collector, error) {
+func NewNfsCollector(logger log.Logger) (Collector, error) {
         fs, err := nfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -86,6 +88,7 @@ func NewNfsCollector() (Collector, error) {
                         []string{"proto", "method"},
                         nil,
                 ),
+                logger: logger,
         }, nil
 }
 
@@ -93,7 +96,7 @@ func (c *nfsCollector) Update(ch chan<- prometheus.Metric) error {
         stats, err := c.fs.ClientRPCStats()
         if err != nil {
                 if os.IsNotExist(err) {
-                        log.Debugf("Not collecting NFS metrics: %s", err)
+                        level.Debug(c.logger).Log("msg", "Not collecting NFS metrics", "err", err)
                         return nil
                 }
                 return fmt.Errorf("failed to retrieve nfs stats: %w", err)
diff --git a/collector/nfsd_linux.go b/collector/nfsd_linux.go
index b5e7cf9..234e1da 100644
--- a/collector/nfsd_linux.go
+++ b/collector/nfsd_linux.go
@@ -17,8 +17,9 @@ import (
         "fmt"
         "os"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs/nfs"
 )
 
@@ -27,6 +28,7 @@ import (
 type nfsdCollector struct {
         fs           nfs.FS
         requestsDesc *prometheus.Desc
+        logger       log.Logger
 }
 
 func init() {
@@ -38,7 +40,7 @@ const (
 )
 
 // NewNFSdCollector returns a new Collector exposing /proc/net/rpc/nfsd statistics.
-func NewNFSdCollector() (Collector, error) {
+func NewNFSdCollector(logger log.Logger) (Collector, error) {
         fs, err := nfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -51,6 +53,7 @@ func NewNFSdCollector() (Collector, error) {
                         "Total number NFSd Requests by method and protocol.",
                         []string{"proto", "method"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
@@ -59,7 +62,7 @@ func (c *nfsdCollector) Update(ch chan<- prometheus.Metric) error {
         stats, err := c.fs.ServerRPCStats()
         if err != nil {
                 if os.IsNotExist(err) {
-                        log.Debugf("Not collecting NFSd metrics: %s", err)
+                        level.Debug(c.logger).Log("msg", "Not collecting NFSd metrics", "err", err)
                         return nil
                 }
                 return fmt.Errorf("failed to retrieve nfsd stats: %w", err)
diff --git a/collector/ntp.go b/collector/ntp.go
index 9b3c5a2..ea3a69e 100644
--- a/collector/ntp.go
+++ b/collector/ntp.go
@@ -22,6 +22,7 @@ import (
         "time"
 
         "github.com/beevik/ntp"
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -47,6 +48,7 @@ var (
 
 type ntpCollector struct {
         stratum, leap, rtt, offset, reftime, rootDelay, rootDispersion, sanity typedDesc
+        logger                                                                 log.Logger
 }
 
 func init() {
@@ -57,7 +59,7 @@ func init() {
 // Default definition of "local" is:
 // - collector.ntp.server address is a loopback address (or collector.ntp.server-is-mine flag is turned on)
 // - the server is reachable with outgoin IP_TTL = 1
-func NewNtpCollector() (Collector, error) {
+func NewNtpCollector(logger log.Logger) (Collector, error) {
         ipaddr := net.ParseIP(*ntpServer)
         if !*ntpServerIsLocal && (ipaddr == nil || !ipaddr.IsLoopback()) {
                 return nil, fmt.Errorf("only IP address of local NTP server is valid for --collector.ntp.server")
@@ -112,6 +114,7 @@ func NewNtpCollector() (Collector, error) {
                         "NTPD sanity according to RFC5905 heuristics and configured limits.",
                         nil, nil,
                 ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/perf_linux.go b/collector/perf_linux.go
index 0ab7b84..0e8a3cc 100644
--- a/collector/perf_linux.go
+++ b/collector/perf_linux.go
@@ -17,7 +17,8 @@ import (
         "fmt"
         "runtime"
 
-        perf "github.com/hodgesds/perf-utils"
+        "github.com/go-kit/kit/log"
+        "github.com/hodgesds/perf-utils"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -29,7 +30,7 @@ func init() {
         registerCollector(perfSubsystem, defaultDisabled, NewPerfCollector)
 }
 
-// perfCollector is a Collecter that uses the perf subsystem to collect
+// perfCollector is a Collector that uses the perf subsystem to collect
 // metrics. It uses perf_event_open an ioctls for profiling. Due to the fact
 // that the perf subsystem is highly dependent on kernel configuration and
 // settings not all profiler values may be exposed on the target system at any
@@ -39,34 +40,36 @@ type perfCollector struct {
         perfSwProfilers    map[int]perf.SoftwareProfiler
         perfCacheProfilers map[int]perf.CacheProfiler
         desc               map[string]*prometheus.Desc
+        logger             log.Logger
 }
 
 // NewPerfCollector returns a new perf based collector, it creates a profiler
 // per CPU.
-func NewPerfCollector() (Collector, error) {
-        collector := &perfCollector{
+func NewPerfCollector(logger log.Logger) (Collector, error) {
+        c := &perfCollector{
                 perfHwProfilers:    map[int]perf.HardwareProfiler{},
                 perfSwProfilers:    map[int]perf.SoftwareProfiler{},
                 perfCacheProfilers: map[int]perf.CacheProfiler{},
+                logger:             logger,
         }
         ncpus := runtime.NumCPU()
         for i := 0; i < ncpus; i++ {
                 // Use -1 to profile all processes on the CPU, see:
                 // man perf_event_open
-                collector.perfHwProfilers[i] = perf.NewHardwareProfiler(-1, i)
-                if err := collector.perfHwProfilers[i].Start(); err != nil {
-                        return collector, err
+                c.perfHwProfilers[i] = perf.NewHardwareProfiler(-1, i)
+                if err := c.perfHwProfilers[i].Start(); err != nil {
+                        return c, err
                 }
-                collector.perfSwProfilers[i] = perf.NewSoftwareProfiler(-1, i)
-                if err := collector.perfSwProfilers[i].Start(); err != nil {
-                        return collector, err
+                c.perfSwProfilers[i] = perf.NewSoftwareProfiler(-1, i)
+                if err := c.perfSwProfilers[i].Start(); err != nil {
+                        return c, err
                 }
-                collector.perfCacheProfilers[i] = perf.NewCacheProfiler(-1, i)
-                if err := collector.perfCacheProfilers[i].Start(); err != nil {
-                        return collector, err
+                c.perfCacheProfilers[i] = perf.NewCacheProfiler(-1, i)
+                if err := c.perfCacheProfilers[i].Start(); err != nil {
+                        return c, err
                 }
         }
-        collector.desc = map[string]*prometheus.Desc{
+        c.desc = map[string]*prometheus.Desc{
                 "cpucycles_total": prometheus.NewDesc(
                         prometheus.BuildFQName(
                                 namespace,
@@ -309,7 +312,7 @@ func NewPerfCollector() (Collector, error) {
                 ),
         }
 
-        return collector, nil
+        return c, nil
 }
 
 // Update implements the Collector interface and will collect metrics per CPU.
diff --git a/collector/perf_linux_test.go b/collector/perf_linux_test.go
index 0b57d10..68c580b 100644
--- a/collector/perf_linux_test.go
+++ b/collector/perf_linux_test.go
@@ -16,6 +16,7 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "io/ioutil"
         "strconv"
         "strings"
@@ -37,7 +38,7 @@ func TestPerfCollector(t *testing.T) {
         if paranoid >= 1 {
                 t.Skip("Skipping perf tests, set perf_event_paranoid to 0")
         }
-        collector, err := NewPerfCollector()
+        collector, err := NewPerfCollector(log.NewNopLogger())
         if err != nil {
                 t.Fatal(err)
         }
diff --git a/collector/powersupplyclass.go b/collector/powersupplyclass.go
index 3b5c8d7..988b0ee 100644
--- a/collector/powersupplyclass.go
+++ b/collector/powersupplyclass.go
@@ -20,6 +20,7 @@ import (
         "fmt"
         "regexp"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/sysfs"
         "gopkg.in/alecthomas/kingpin.v2"
@@ -33,18 +34,20 @@ type powerSupplyClassCollector struct {
         subsystem      string
         ignoredPattern *regexp.Regexp
         metricDescs    map[string]*prometheus.Desc
+        logger         log.Logger
 }
 
 func init() {
         registerCollector("powersupplyclass", defaultEnabled, NewPowerSupplyClassCollector)
 }
 
-func NewPowerSupplyClassCollector() (Collector, error) {
+func NewPowerSupplyClassCollector(logger log.Logger) (Collector, error) {
         pattern := regexp.MustCompile(*powerSupplyClassIgnoredPowerSupplies)
         return &powerSupplyClassCollector{
                 subsystem:      "power_supply",
                 ignoredPattern: pattern,
                 metricDescs:    map[string]*prometheus.Desc{},
+                logger:         logger,
         }, nil
 }
 
diff --git a/collector/pressure_linux.go b/collector/pressure_linux.go
index 2ed7ffb..8f0b8db 100644
--- a/collector/pressure_linux.go
+++ b/collector/pressure_linux.go
@@ -18,8 +18,9 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
@@ -35,6 +36,8 @@ type pressureStatsCollector struct {
         memFull *prometheus.Desc
 
         fs procfs.FS
+
+        logger log.Logger
 }
 
 func init() {
@@ -42,7 +45,7 @@ func init() {
 }
 
 // NewPressureStatsCollector returns a Collector exposing pressure stall information
-func NewPressureStatsCollector() (Collector, error) {
+func NewPressureStatsCollector(logger log.Logger) (Collector, error) {
         fs, err := procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -74,17 +77,18 @@ func NewPressureStatsCollector() (Collector, error) {
                         "Total time in seconds no process could make progress due to memory congestion",
                         nil, nil,
                 ),
-                fs: fs,
+                fs:     fs,
+                logger: logger,
         }, nil
 }
 
 // Update calls procfs.NewPSIStatsForResource for the different resources and updates the values
 func (c *pressureStatsCollector) Update(ch chan<- prometheus.Metric) error {
         for _, res := range psiResources {
-                log.Debugf("collecting statistics for resource: %s", res)
+                level.Debug(c.logger).Log("msg", "collecting statistics for resource", "resource", res)
                 vals, err := c.fs.PSIStatsForResource(res)
                 if err != nil {
-                        log.Debug("pressure information is unavailable, you need a Linux kernel >= 4.20 and/or CONFIG_PSI enabled for your kernel")
+                        level.Debug(c.logger).Log("msg", "pressure information is unavailable, you need a Linux kernel >= 4.20 and/or CONFIG_PSI enabled for your kernel")
                         return nil
                 }
                 switch res {
@@ -97,7 +101,7 @@ func (c *pressureStatsCollector) Update(ch chan<- prometheus.Metric) error {
                         ch <- prometheus.MustNewConstMetric(c.mem, prometheus.CounterValue, float64(vals.Some.Total)/1000.0/1000.0)
                         ch <- prometheus.MustNewConstMetric(c.memFull, prometheus.CounterValue, float64(vals.Full.Total)/1000.0/1000.0)
                 default:
-                        log.Debugf("did not account for resource: %s", res)
+                        level.Debug(c.logger).Log("msg", "did not account for resource", "resource", res)
                 }
         }
 
diff --git a/collector/processes_linux.go b/collector/processes_linux.go
index bb18a69..3d64cbd 100644
--- a/collector/processes_linux.go
+++ b/collector/processes_linux.go
@@ -19,8 +19,9 @@ import (
         "fmt"
         "os"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
@@ -31,6 +32,7 @@ type processCollector struct {
         procsState  *prometheus.Desc
         pidUsed     *prometheus.Desc
         pidMax      *prometheus.Desc
+        logger      log.Logger
 }
 
 func init() {
@@ -38,7 +40,7 @@ func init() {
 }
 
 // NewProcessStatCollector returns a new Collector exposing process data read from the proc filesystem.
-func NewProcessStatCollector() (Collector, error) {
+func NewProcessStatCollector(logger log.Logger) (Collector, error) {
         fs, err := procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -67,6 +69,7 @@ func NewProcessStatCollector() (Collector, error) {
                 pidMax: prometheus.NewDesc(prometheus.BuildFQName(namespace, subsystem, "max_processes"),
                         "Number of max PIDs limit", nil, nil,
                 ),
+                logger: logger,
         }, nil
 }
 func (c *processCollector) Update(ch chan<- prometheus.Metric) error {
@@ -108,11 +111,11 @@ func (c *processCollector) getAllocatedThreads() (int, map[string]int32, int, er
                 stat, err := pid.Stat()
                 // PIDs can vanish between getting the list and getting stats.
                 if os.IsNotExist(err) {
-                        log.Debugf("file not found when retrieving stats for pid %v: %q", pid, err)
+                        level.Debug(c.logger).Log("msg", "file not found when retrieving stats for pid", "pid", pid, "err", err)
                         continue
                 }
                 if err != nil {
-                        log.Debugf("error reading stat for pid %v: %q", pid, err)
+                        level.Debug(c.logger).Log("msg", "error reading stat for pid", "pid", pid, "err", err)
                         return 0, nil, 0, err
                 }
                 pids++
diff --git a/collector/processes_linux_test.go b/collector/processes_linux_test.go
index dc71ced..cb01fbb 100644
--- a/collector/processes_linux_test.go
+++ b/collector/processes_linux_test.go
@@ -16,6 +16,7 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "testing"
 
         "github.com/prometheus/procfs"
@@ -31,7 +32,7 @@ func TestReadProcessStatus(t *testing.T) {
         if err != nil {
                 t.Errorf("failed to open procfs: %v", err)
         }
-        c := processCollector{fs: fs}
+        c := processCollector{fs: fs, logger: log.NewNopLogger()}
         pids, states, threads, err := c.getAllocatedThreads()
         if err != nil {
                 t.Fatalf("Cannot retrieve data from procfs getAllocatedThreads function: %v ", err)
diff --git a/collector/qdisc_linux.go b/collector/qdisc_linux.go
index 74757b3..daba199 100644
--- a/collector/qdisc_linux.go
+++ b/collector/qdisc_linux.go
@@ -21,6 +21,7 @@ import (
         "path/filepath"
 
         "github.com/ema/qdisc"
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -31,6 +32,7 @@ type qdiscStatCollector struct {
         drops      typedDesc
         requeues   typedDesc
         overlimits typedDesc
+        logger     log.Logger
 }
 
 var (
@@ -42,7 +44,7 @@ func init() {
 }
 
 // NewQdiscStatCollector returns a new Collector exposing queuing discipline statistics.
-func NewQdiscStatCollector() (Collector, error) {
+func NewQdiscStatCollector(logger log.Logger) (Collector, error) {
         return &qdiscStatCollector{
                 bytes: typedDesc{prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, "qdisc", "bytes_total"),
@@ -69,6 +71,7 @@ func NewQdiscStatCollector() (Collector, error) {
                         "Number of overlimit packets.",
                         []string{"device", "kind"}, nil,
                 ), prometheus.CounterValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/runit.go b/collector/runit.go
index 2608e1b..9d88904 100644
--- a/collector/runit.go
+++ b/collector/runit.go
@@ -16,8 +16,9 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/soundcloud/go-runit/runit"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -25,7 +26,11 @@ import (
 var runitServiceDir = kingpin.Flag("collector.runit.servicedir", "Path to runit service directory.").Default("/etc/service").String()
 
 type runitCollector struct {
-        state, stateDesired, stateNormal, stateTimestamp typedDesc
+        state          typedDesc
+        stateDesired   typedDesc
+        stateNormal    typedDesc
+        stateTimestamp typedDesc
+        logger         log.Logger
 }
 
 func init() {
@@ -33,7 +38,7 @@ func init() {
 }
 
 // NewRunitCollector returns a new Collector exposing runit statistics.
-func NewRunitCollector() (Collector, error) {
+func NewRunitCollector(logger log.Logger) (Collector, error) {
         var (
                 subsystem   = "service"
                 constLabels = prometheus.Labels{"supervisor": "runit"}
@@ -61,6 +66,7 @@ func NewRunitCollector() (Collector, error) {
                         "Unix timestamp of the last runit service state change.",
                         labelNames, constLabels,
                 ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
@@ -73,11 +79,11 @@ func (c *runitCollector) Update(ch chan<- prometheus.Metric) error {
         for _, service := range services {
                 status, err := service.Status()
                 if err != nil {
-                        log.Debugf("Couldn't get status for %s: %s, skipping...", service.Name, err)
+                        level.Debug(c.logger).Log("msg", "Couldn't get status", "service", service.Name, "err", err)
                         continue
                 }
 
-                log.Debugf("%s is %d on pid %d for %d seconds", service.Name, status.State, status.Pid, status.Duration)
+                level.Debug(c.logger).Log("msg", "duration", "service", service.Name, "status", status.State, "pid", status.Pid, "duration_seconds", status.Duration)
                 ch <- c.state.mustNewConstMetric(float64(status.State), service.Name)
                 ch <- c.stateDesired.mustNewConstMetric(float64(status.Want), service.Name)
                 ch <- c.stateTimestamp.mustNewConstMetric(float64(status.Timestamp.Unix()), service.Name)
diff --git a/collector/schedstat_linux.go b/collector/schedstat_linux.go
index 1c91a47..6810b93 100644
--- a/collector/schedstat_linux.go
+++ b/collector/schedstat_linux.go
@@ -16,6 +16,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs"
 )
@@ -46,17 +47,18 @@ var (
 )
 
 // NewSchedstatCollector returns a new Collector exposing task scheduler statistics
-func NewSchedstatCollector() (Collector, error) {
+func NewSchedstatCollector(logger log.Logger) (Collector, error) {
         fs, err := procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
         }
 
-        return &schedstatCollector{fs: fs}, nil
+        return &schedstatCollector{fs, logger}, nil
 }
 
 type schedstatCollector struct {
-        fs procfs.FS
+        fs     procfs.FS
+        logger log.Logger
 }
 
 func init() {
diff --git a/collector/sockstat_linux.go b/collector/sockstat_linux.go
index fceb0ed..c7596c9 100644
--- a/collector/sockstat_linux.go
+++ b/collector/sockstat_linux.go
@@ -19,8 +19,9 @@ import (
         "fmt"
         "os"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/procfs"
 )
 
@@ -31,15 +32,17 @@ const (
 // Used for calculating the total memory bytes on TCP and UDP.
 var pageSize = os.Getpagesize()
 
-type sockStatCollector struct{}
+type sockStatCollector struct {
+        logger log.Logger
+}
 
 func init() {
         registerCollector(sockStatSubsystem, defaultEnabled, NewSockStatCollector)
 }
 
 // NewSockStatCollector returns a new Collector exposing socket stats.
-func NewSockStatCollector() (Collector, error) {
-        return &sockStatCollector{}, nil
+func NewSockStatCollector(logger log.Logger) (Collector, error) {
+        return &sockStatCollector{logger}, nil
 }
 
 func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
@@ -53,7 +56,7 @@ func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
         switch {
         case err == nil:
         case os.IsNotExist(err):
-                log.Debug("IPv4 sockstat statistics not found, skipping")
+                level.Debug(c.logger).Log("msg", "IPv4 sockstat statistics not found, skipping")
         default:
                 return fmt.Errorf("failed to get IPv4 sockstat data: %w", err)
         }
@@ -62,7 +65,7 @@ func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
         switch {
         case err == nil:
         case os.IsNotExist(err):
-                log.Debug("IPv6 sockstat statistics not found, skipping")
+                level.Debug(c.logger).Log("msg", "IPv6 sockstat statistics not found, skipping")
         default:
                 return fmt.Errorf("failed to get IPv6 sockstat data: %w", err)
         }
diff --git a/collector/stat_linux.go b/collector/stat_linux.go
index 5e51d96..667d962 100644
--- a/collector/stat_linux.go
+++ b/collector/stat_linux.go
@@ -18,9 +18,9 @@ package collector
 import (
         "fmt"
 
-        "github.com/prometheus/procfs"
-
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
+        "github.com/prometheus/procfs"
 )
 
 type statCollector struct {
@@ -31,6 +31,7 @@ type statCollector struct {
         btime        *prometheus.Desc
         procsRunning *prometheus.Desc
         procsBlocked *prometheus.Desc
+        logger       log.Logger
 }
 
 func init() {
@@ -38,7 +39,7 @@ func init() {
 }
 
 // NewStatCollector returns a new Collector exposing kernel/system statistics.
-func NewStatCollector() (Collector, error) {
+func NewStatCollector(logger log.Logger) (Collector, error) {
         fs, err := procfs.NewFS(*procPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open procfs: %w", err)
@@ -75,6 +76,7 @@ func NewStatCollector() (Collector, error) {
                         "Number of processes blocked waiting for I/O to complete.",
                         nil, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/supervisord.go b/collector/supervisord.go
index 0e32540..a182062 100644
--- a/collector/supervisord.go
+++ b/collector/supervisord.go
@@ -18,9 +18,10 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/mattn/go-xmlrpc"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -33,6 +34,7 @@ type supervisordCollector struct {
         stateDesc      *prometheus.Desc
         exitStatusDesc *prometheus.Desc
         startTimeDesc  *prometheus.Desc
+        logger         log.Logger
 }
 
 func init() {
@@ -40,7 +42,7 @@ func init() {
 }
 
 // NewSupervisordCollector returns a new Collector exposing supervisord statistics.
-func NewSupervisordCollector() (Collector, error) {
+func NewSupervisordCollector(logger log.Logger) (Collector, error) {
         var (
                 subsystem  = "supervisord"
                 labelNames = []string{"name", "group"}
@@ -70,6 +72,7 @@ func NewSupervisordCollector() (Collector, error) {
                         labelNames,
                         nil,
                 ),
+                logger: logger,
         }, nil
 }
 
@@ -147,7 +150,7 @@ func (c *supervisordCollector) Update(ch chan<- prometheus.Metric) error {
                 } else {
                         ch <- prometheus.MustNewConstMetric(c.upDesc, prometheus.GaugeValue, 0, labels...)
                 }
-                log.Debugf("%s:%s is %s on pid %d", info.Group, info.Name, info.StateName, info.PID)
+                level.Debug(c.logger).Log("msg", "process info", "group", info.Group, "name", info.Name, "state", info.StateName, "pid", info.PID)
         }
 
         return nil
diff --git a/collector/systemd_linux.go b/collector/systemd_linux.go
index eb1fa78..3c55f4d 100644
--- a/collector/systemd_linux.go
+++ b/collector/systemd_linux.go
@@ -25,8 +25,9 @@ import (
         "time"
 
         "github.com/coreos/go-systemd/dbus"
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         kingpin "gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -62,6 +63,7 @@ type systemdCollector struct {
         systemdVersion                int
         unitWhitelistPattern          *regexp.Regexp
         unitBlacklistPattern          *regexp.Regexp
+        logger                        log.Logger
 }
 
 var unitStatesName = []string{"active", "activating", "deactivating", "inactive", "failed"}
@@ -71,7 +73,7 @@ func init() {
 }
 
 // NewSystemdCollector returns a new Collector exposing systemd statistics.
-func NewSystemdCollector() (Collector, error) {
+func NewSystemdCollector(logger log.Logger) (Collector, error) {
         const subsystem = "systemd"
 
         unitDesc := prometheus.NewDesc(
@@ -119,10 +121,10 @@ func NewSystemdCollector() (Collector, error) {
         unitWhitelistPattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *unitWhitelist))
         unitBlacklistPattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *unitBlacklist))
 
-        systemdVersion := getSystemdVersion()
+        systemdVersion := getSystemdVersion(logger)
         if systemdVersion < minSystemdVersionSystemState {
-                log.Warnf("Detected systemd version %v is lower than minimum %v", systemdVersion, minSystemdVersionSystemState)
-                log.Warn("Some systemd state and timer metrics will not be available")
+                level.Warn(logger).Log("msg", "Detected systemd version is lower than minimum", "current", systemdVersion, "minimum", minSystemdVersionSystemState)
+                level.Warn(logger).Log("msg", "Some systemd state and timer metrics will not be available")
         }
 
         return &systemdCollector{
@@ -141,6 +143,7 @@ func NewSystemdCollector() (Collector, error) {
                 systemdVersion:                systemdVersion,
                 unitWhitelistPattern:          unitWhitelistPattern,
                 unitBlacklistPattern:          unitBlacklistPattern,
+                logger:                        logger,
         }, nil
 }
 
@@ -158,16 +161,16 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
         if err != nil {
                 return fmt.Errorf("couldn't get units: %s", err)
         }
-        log.Debugf("systemd getAllUnits took %f", time.Since(begin).Seconds())
+        level.Debug(c.logger).Log("msg", "getAllUnits took", "duration_seconds", time.Since(begin).Seconds())
 
         begin = time.Now()
         summary := summarizeUnits(allUnits)
         c.collectSummaryMetrics(ch, summary)
-        log.Debugf("systemd collectSummaryMetrics took %f", time.Since(begin).Seconds())
+        level.Debug(c.logger).Log("msg", "collectSummaryMetrics took", "duration_seconds", time.Since(begin).Seconds())
 
         begin = time.Now()
-        units := filterUnits(allUnits, c.unitWhitelistPattern, c.unitBlacklistPattern)
-        log.Debugf("systemd filterUnits took %f", time.Since(begin).Seconds())
+        units := filterUnits(allUnits, c.unitWhitelistPattern, c.unitBlacklistPattern, c.logger)
+        level.Debug(c.logger).Log("msg", "filterUnits took", "duration_seconds", time.Since(begin).Seconds())
 
         var wg sync.WaitGroup
         defer wg.Wait()
@@ -177,7 +180,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
                 defer wg.Done()
                 begin = time.Now()
                 c.collectUnitStatusMetrics(conn, ch, units)
-                log.Debugf("systemd collectUnitStatusMetrics took %f", time.Since(begin).Seconds())
+                level.Debug(c.logger).Log("msg", "collectUnitStatusMetrics took", "duration_seconds", time.Since(begin).Seconds())
         }()
 
         if *enableStartTimeMetrics {
@@ -186,7 +189,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
                         defer wg.Done()
                         begin = time.Now()
                         c.collectUnitStartTimeMetrics(conn, ch, units)
-                        log.Debugf("systemd collectUnitStartTimeMetrics took %f", time.Since(begin).Seconds())
+                        level.Debug(c.logger).Log("msg", "collectUnitStartTimeMetrics took", "duration_seconds", time.Since(begin).Seconds())
                 }()
         }
 
@@ -196,7 +199,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
                         defer wg.Done()
                         begin = time.Now()
                         c.collectUnitTasksMetrics(conn, ch, units)
-                        log.Debugf("systemd collectUnitTasksMetrics took %f", time.Since(begin).Seconds())
+                        level.Debug(c.logger).Log("msg", "collectUnitTasksMetrics took", "duration_seconds", time.Since(begin).Seconds())
                 }()
         }
 
@@ -206,7 +209,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
                         defer wg.Done()
                         begin = time.Now()
                         c.collectTimers(conn, ch, units)
-                        log.Debugf("systemd collectTimers took %f", time.Since(begin).Seconds())
+                        level.Debug(c.logger).Log("msg", "collectTimers took", "duration_seconds", time.Since(begin).Seconds())
                 }()
         }
 
@@ -215,13 +218,13 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
                 defer wg.Done()
                 begin = time.Now()
                 c.collectSockets(conn, ch, units)
-                log.Debugf("systemd collectSockets took %f", time.Since(begin).Seconds())
+                level.Debug(c.logger).Log("msg", "collectSockets took", "duration_seconds", time.Since(begin).Seconds())
         }()
 
         if c.systemdVersion >= minSystemdVersionSystemState {
                 begin = time.Now()
                 err = c.collectSystemState(conn, ch)
-                log.Debugf("systemd collectSystemState took %f", time.Since(begin).Seconds())
+                level.Debug(c.logger).Log("msg", "collectSystemState took", "duration_seconds", time.Since(begin).Seconds())
         }
 
         ch <- prometheus.MustNewConstMetric(
@@ -236,14 +239,14 @@ func (c *systemdCollector) collectUnitStatusMetrics(conn *dbus.Conn, ch chan<- p
                 if strings.HasSuffix(unit.Name, ".service") {
                         serviceTypeProperty, err := conn.GetUnitTypeProperty(unit.Name, "Service", "Type")
                         if err != nil {
-                                log.Debugf("couldn't get unit '%s' Type: %s", unit.Name, err)
+                                level.Debug(c.logger).Log("msg", "couldn't get unit type", "unit", unit.Name, "err", err)
                         } else {
                                 serviceType = serviceTypeProperty.Value.Value().(string)
                         }
                 } else if strings.HasSuffix(unit.Name, ".mount") {
                         serviceTypeProperty, err := conn.GetUnitTypeProperty(unit.Name, "Mount", "Type")
                         if err != nil {
-                                log.Debugf("couldn't get unit '%s' Type: %s", unit.Name, err)
+                                level.Debug(c.logger).Log("msg", "couldn't get unit type", "unit", unit.Name, "err", err)
                         } else {
                                 serviceType = serviceTypeProperty.Value.Value().(string)
                         }
@@ -261,7 +264,7 @@ func (c *systemdCollector) collectUnitStatusMetrics(conn *dbus.Conn, ch chan<- p
                         // NRestarts wasn't added until systemd 235.
                         restartsCount, err := conn.GetUnitTypeProperty(unit.Name, "Service", "NRestarts")
                         if err != nil {
-                                log.Debugf("couldn't get unit '%s' NRestarts: %s", unit.Name, err)
+                                level.Debug(c.logger).Log("msg", "couldn't get unit NRestarts", "unit", unit.Name, "err", err)
                         } else {
                                 ch <- prometheus.MustNewConstMetric(
                                         c.nRestartsDesc, prometheus.CounterValue,
@@ -279,7 +282,7 @@ func (c *systemdCollector) collectSockets(conn *dbus.Conn, ch chan<- prometheus.
 
                 acceptedConnectionCount, err := conn.GetUnitTypeProperty(unit.Name, "Socket", "NAccepted")
                 if err != nil {
-                        log.Debugf("couldn't get unit '%s' NAccepted: %s", unit.Name, err)
+                        level.Debug(c.logger).Log("msg", "couldn't get unit NAccepted", "unit", unit.Name, "err", err)
                         continue
                 }
                 ch <- prometheus.MustNewConstMetric(
@@ -288,7 +291,7 @@ func (c *systemdCollector) collectSockets(conn *dbus.Conn, ch chan<- prometheus.
 
                 currentConnectionCount, err := conn.GetUnitTypeProperty(unit.Name, "Socket", "NConnections")
                 if err != nil {
-                        log.Debugf("couldn't get unit '%s' NConnections: %s", unit.Name, err)
+                        level.Debug(c.logger).Log("msg", "couldn't get unit NConnections", "unit", unit.Name, "err", err)
                         continue
                 }
                 ch <- prometheus.MustNewConstMetric(
@@ -316,7 +319,7 @@ func (c *systemdCollector) collectUnitStartTimeMetrics(conn *dbus.Conn, ch chan<
                 } else {
                         timestampValue, err := conn.GetUnitProperty(unit.Name, "ActiveEnterTimestamp")
                         if err != nil {
-                                log.Debugf("couldn't get unit '%s' StartTimeUsec: %s", unit.Name, err)
+                                level.Debug(c.logger).Log("msg", "couldn't get unit StartTimeUsec", "unit", unit.Name, "err", err)
                                 continue
                         }
                         startTimeUsec = timestampValue.Value.Value().(uint64)
@@ -334,7 +337,7 @@ func (c *systemdCollector) collectUnitTasksMetrics(conn *dbus.Conn, ch chan<- pr
                 if strings.HasSuffix(unit.Name, ".service") {
                         tasksCurrentCount, err := conn.GetUnitTypeProperty(unit.Name, "Service", "TasksCurrent")
                         if err != nil {
-                                log.Debugf("couldn't get unit '%s' TasksCurrent: %s", unit.Name, err)
+                                level.Debug(c.logger).Log("msg", "couldn't get unit TasksCurrent", "unit", unit.Name, "err", err)
                         } else {
                                 val = tasksCurrentCount.Value.Value().(uint64)
                                 // Don't set if tasksCurrent if dbus reports MaxUint64.
@@ -346,7 +349,7 @@ func (c *systemdCollector) collectUnitTasksMetrics(conn *dbus.Conn, ch chan<- pr
                         }
                         tasksMaxCount, err := conn.GetUnitTypeProperty(unit.Name, "Service", "TasksMax")
                         if err != nil {
-                                log.Debugf("couldn't get unit '%s' TasksMax: %s", unit.Name, err)
+                                level.Debug(c.logger).Log("msg", "couldn't get unit TasksMax", "unit", unit.Name, "err", err)
                         } else {
                                 val = tasksMaxCount.Value.Value().(uint64)
                                 // Don't set if tasksMax if dbus reports MaxUint64.
@@ -368,7 +371,7 @@ func (c *systemdCollector) collectTimers(conn *dbus.Conn, ch chan<- prometheus.M
 
                 lastTriggerValue, err := conn.GetUnitTypeProperty(unit.Name, "Timer", "LastTriggerUSec")
                 if err != nil {
-                        log.Debugf("couldn't get unit '%s' LastTriggerUSec: %s", unit.Name, err)
+                        level.Debug(c.logger).Log("msg", "couldn't get unit LastTriggerUSec", "unit", unit.Name, "err", err)
                         continue
                 }
 
@@ -440,36 +443,36 @@ func summarizeUnits(units []unit) map[string]float64 {
         return summarized
 }
 
-func filterUnits(units []unit, whitelistPattern, blacklistPattern *regexp.Regexp) []unit {
+func filterUnits(units []unit, whitelistPattern, blacklistPattern *regexp.Regexp, logger log.Logger) []unit {
         filtered := make([]unit, 0, len(units))
         for _, unit := range units {
                 if whitelistPattern.MatchString(unit.Name) && !blacklistPattern.MatchString(unit.Name) && unit.LoadState == "loaded" {
-                        log.Debugf("Adding unit: %s", unit.Name)
+                        level.Debug(logger).Log("msg", "Adding unit", "unit", unit.Name)
                         filtered = append(filtered, unit)
                 } else {
-                        log.Debugf("Ignoring unit: %s", unit.Name)
+                        level.Debug(logger).Log("msg", "Ignoring unit", "unit", unit.Name)
                 }
         }
 
         return filtered
 }
 
-func getSystemdVersion() int {
+func getSystemdVersion(logger log.Logger) int {
         conn, err := newSystemdDbusConn()
         if err != nil {
-                log.Warnf("Unable to get systemd dbus connection, defaulting systemd version to 0: %s", err)
+                level.Warn(logger).Log("msg", "Unable to get systemd dbus connection, defaulting systemd version to 0", "err", err)
                 return 0
         }
         defer conn.Close()
         version, err := conn.GetManagerProperty("Version")
         if err != nil {
-                log.Warn("Unable to get systemd version property, defaulting to 0")
+                level.Warn(logger).Log("msg", "Unable to get systemd version property, defaulting to 0")
                 return 0
         }
         version = strings.Replace(version, "\"", "", 2)
         v, err := strconv.Atoi(version)
         if err != nil {
-                log.Warnf("Got invalid systemd version: %v", version)
+                level.Warn(logger).Log("msg", "Got invalid systemd version", "version", version)
                 return 0
         }
         return v
diff --git a/collector/systemd_linux_test.go b/collector/systemd_linux_test.go
index b2298d6..613a1ab 100644
--- a/collector/systemd_linux_test.go
+++ b/collector/systemd_linux_test.go
@@ -14,6 +14,7 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "regexp"
         "testing"
 
@@ -90,7 +91,7 @@ func TestSystemdIgnoreFilter(t *testing.T) {
         fixtures := getUnitListFixtures()
         whitelistPattern := regexp.MustCompile("^foo$")
         blacklistPattern := regexp.MustCompile("^bar$")
-        filtered := filterUnits(fixtures[0], whitelistPattern, blacklistPattern)
+        filtered := filterUnits(fixtures[0], whitelistPattern, blacklistPattern, log.NewNopLogger())
         for _, unit := range filtered {
                 if blacklistPattern.MatchString(unit.Name) || !whitelistPattern.MatchString(unit.Name) {
                         t.Error(unit.Name, "should not be in the filtered list")
@@ -98,13 +99,14 @@ func TestSystemdIgnoreFilter(t *testing.T) {
         }
 }
 func TestSystemdIgnoreFilterDefaultKeepsAll(t *testing.T) {
-        c, err := NewSystemdCollector()
+        logger := log.NewNopLogger()
+        c, err := NewSystemdCollector(logger)
         if err != nil {
                 t.Fatal(err)
         }
         fixtures := getUnitListFixtures()
         collector := c.(*systemdCollector)
-        filtered := filterUnits(fixtures[0], collector.unitWhitelistPattern, collector.unitBlacklistPattern)
+        filtered := filterUnits(fixtures[0], collector.unitWhitelistPattern, collector.unitBlacklistPattern, logger)
         // Adjust fixtures by 3 "not-found" units.
         if len(filtered) != len(fixtures[0])-3 {
                 t.Error("Default filters removed units")
diff --git a/collector/tcpstat_linux.go b/collector/tcpstat_linux.go
index cc4e960..9b09e9a 100644
--- a/collector/tcpstat_linux.go
+++ b/collector/tcpstat_linux.go
@@ -23,6 +23,7 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -54,7 +55,8 @@ const (
 )
 
 type tcpStatCollector struct {
-        desc typedDesc
+        desc   typedDesc
+        logger log.Logger
 }
 
 func init() {
@@ -62,13 +64,14 @@ func init() {
 }
 
 // NewTCPStatCollector returns a new Collector exposing network stats.
-func NewTCPStatCollector() (Collector, error) {
+func NewTCPStatCollector(logger log.Logger) (Collector, error) {
         return &tcpStatCollector{
                 desc: typedDesc{prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, "tcp", "connection_states"),
                         "Number of connection states.",
                         []string{"state"}, nil,
                 ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/textfile.go b/collector/textfile.go
index aee11db..64165e6 100644
--- a/collector/textfile.go
+++ b/collector/textfile.go
@@ -24,10 +24,11 @@ import (
         "strings"
         "time"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
         dto "github.com/prometheus/client_model/go"
         "github.com/prometheus/common/expfmt"
-        "github.com/prometheus/common/log"
         kingpin "gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -44,7 +45,8 @@ var (
 type textFileCollector struct {
         path string
         // Only set for testing to get predictable output.
-        mtime *float64
+        mtime  *float64
+        logger log.Logger
 }
 
 func init() {
@@ -53,14 +55,15 @@ func init() {
 
 // NewTextFileCollector returns a new Collector exposing metrics read from files
 // in the given textfile directory.
-func NewTextFileCollector() (Collector, error) {
+func NewTextFileCollector(logger log.Logger) (Collector, error) {
         c := &textFileCollector{
-                path: *textFileDirectory,
+                path:   *textFileDirectory,
+                logger: logger,
         }
         return c, nil
 }
 
-func convertMetricFamily(metricFamily *dto.MetricFamily, ch chan<- prometheus.Metric) {
+func convertMetricFamily(metricFamily *dto.MetricFamily, ch chan<- prometheus.Metric, logger log.Logger) {
         var valType prometheus.ValueType
         var val float64
 
@@ -76,7 +79,7 @@ func convertMetricFamily(metricFamily *dto.MetricFamily, ch chan<- prometheus.Me
 
         for _, metric := range metricFamily.Metric {
                 if metric.TimestampMs != nil {
-                        log.Warnf("Ignoring unsupported custom timestamp on textfile collector metric %v", metric)
+                        level.Warn(logger).Log("msg", "Ignoring unsupported custom timestamp on textfile collector metric", "metric", metric)
                 }
 
                 labels := metric.GetLabel()
@@ -191,7 +194,7 @@ func (c *textFileCollector) Update(ch chan<- prometheus.Metric) error {
         files, err := ioutil.ReadDir(c.path)
         if err != nil && c.path != "" {
                 errored = true
-                log.Errorf("failed to read textfile collector directory %q: %v", c.path, err)
+                level.Error(c.logger).Log("msg", "failed to read textfile collector directory", "path", c.path, "err", err)
         }
 
         mtimes := make(map[string]time.Time, len(files))
@@ -203,7 +206,7 @@ func (c *textFileCollector) Update(ch chan<- prometheus.Metric) error {
                 mtime, err := c.processFile(f.Name(), ch)
                 if err != nil {
                         errored = true
-                        log.Errorf("failed to collect textfile data from %q: %v", f.Name(), err)
+                        level.Error(c.logger).Log("msg", "failed to collect textfile data", "file", f.Name(), "err", err)
                         continue
                 }
 
@@ -257,7 +260,7 @@ func (c *textFileCollector) processFile(name string, ch chan<- prometheus.Metric
         }
 
         for _, mf := range families {
-                convertMetricFamily(mf, ch)
+                convertMetricFamily(mf, ch, c.logger)
         }
 
         // Only stat the file once it has been parsed and validated, so that
diff --git a/collector/textfile_test.go b/collector/textfile_test.go
index fb1a700..f0e93a8 100644
--- a/collector/textfile_test.go
+++ b/collector/textfile_test.go
@@ -20,10 +20,12 @@ import (
         "net/http/httptest"
         "testing"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/client_golang/prometheus/promhttp"
-        "github.com/prometheus/common/log"
-        kingpin "gopkg.in/alecthomas/kingpin.v2"
+        "github.com/prometheus/common/promlog"
+        "github.com/prometheus/common/promlog/flag"
+        "gopkg.in/alecthomas/kingpin.v2"
 )
 
 type collectorAdapter struct {
@@ -39,8 +41,7 @@ func (a collectorAdapter) Describe(ch chan<- *prometheus.Desc) {
 
 // Collect implements the prometheus.Collector interface.
 func (a collectorAdapter) Collect(ch chan<- prometheus.Metric) {
-        err := a.Update(ch)
-        if err != nil {
+        if err := a.Update(ch); err != nil {
                 panic(fmt.Sprintf("failed to update collector: %v", err))
         }
 }
@@ -95,15 +96,16 @@ func TestTextfileCollector(t *testing.T) {
         for i, test := range tests {
                 mtime := 1.0
                 c := &textFileCollector{
-                        path:  test.path,
-                        mtime: &mtime,
+                        path:   test.path,
+                        mtime:  &mtime,
+                        logger: log.NewNopLogger(),
                 }
 
                 // Suppress a log message about `nonexistent_path` not existing, this is
                 // expected and clutters the test output.
-                log.AddFlags(kingpin.CommandLine)
-                _, err := kingpin.CommandLine.Parse([]string{"--log.level", "fatal"})
-                if err != nil {
+                promlogConfig := &promlog.Config{}
+                flag.AddFlags(kingpin.CommandLine, promlogConfig)
+                if _, err := kingpin.CommandLine.Parse([]string{"--log.level", "debug"}); err != nil {
                         t.Fatal(err)
                 }
 
diff --git a/collector/thermal_zone_linux.go b/collector/thermal_zone_linux.go
index b8a65cf..5d223bc 100644
--- a/collector/thermal_zone_linux.go
+++ b/collector/thermal_zone_linux.go
@@ -18,6 +18,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/sysfs"
 )
@@ -30,6 +31,7 @@ type thermalZoneCollector struct {
         coolingDeviceCurState *prometheus.Desc
         coolingDeviceMaxState *prometheus.Desc
         zoneTemp              *prometheus.Desc
+        logger                log.Logger
 }
 
 func init() {
@@ -37,7 +39,7 @@ func init() {
 }
 
 // NewThermalZoneCollector returns a new Collector exposing kernel/system statistics.
-func NewThermalZoneCollector() (Collector, error) {
+func NewThermalZoneCollector(logger log.Logger) (Collector, error) {
         fs, err := sysfs.NewFS(*sysPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open sysfs: %w", err)
@@ -60,6 +62,7 @@ func NewThermalZoneCollector() (Collector, error) {
                         "Maximum throttle state of the cooling device",
                         []string{"name", "type"}, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/time.go b/collector/time.go
index eb57bd8..76a2d1e 100644
--- a/collector/time.go
+++ b/collector/time.go
@@ -18,12 +18,14 @@ package collector
 import (
         "time"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 type timeCollector struct {
-        desc *prometheus.Desc
+        desc   *prometheus.Desc
+        logger log.Logger
 }
 
 func init() {
@@ -32,19 +34,20 @@ func init() {
 
 // NewTimeCollector returns a new Collector exposing the current system time in
 // seconds since epoch.
-func NewTimeCollector() (Collector, error) {
+func NewTimeCollector(logger log.Logger) (Collector, error) {
         return &timeCollector{
                 desc: prometheus.NewDesc(
                         namespace+"_time_seconds",
                         "System time in seconds since epoch (1970).",
                         nil, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
 func (c *timeCollector) Update(ch chan<- prometheus.Metric) error {
         now := float64(time.Now().UnixNano()) / 1e9
-        log.Debugf("Return time: %f", now)
+        level.Debug(c.logger).Log("msg", "Return time", "now", now)
         ch <- prometheus.MustNewConstMetric(c.desc, prometheus.GaugeValue, now)
         return nil
 }
diff --git a/collector/timex.go b/collector/timex.go
index 7ef6920..4dc4d6c 100644
--- a/collector/timex.go
+++ b/collector/timex.go
@@ -19,6 +19,7 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "golang.org/x/sys/unix"
 )
@@ -54,6 +55,7 @@ type timexCollector struct {
         stbcnt,
         tai,
         syncStatus typedDesc
+        logger log.Logger
 }
 
 func init() {
@@ -61,7 +63,7 @@ func init() {
 }
 
 // NewTimexCollector returns a new Collector exposing adjtime(3) stats.
-func NewTimexCollector() (Collector, error) {
+func NewTimexCollector(logger log.Logger) (Collector, error) {
         const subsystem = "timex"
 
         return &timexCollector{
@@ -150,6 +152,7 @@ func NewTimexCollector() (Collector, error) {
                         "Is clock synchronized to a reliable server (1 = yes, 0 = no).",
                         nil, nil,
                 ), prometheus.GaugeValue},
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/uname.go b/collector/uname.go
index 381c0ae..2c0c306 100644
--- a/collector/uname.go
+++ b/collector/uname.go
@@ -17,6 +17,7 @@
 package collector
 
 import (
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
@@ -34,7 +35,9 @@ var unameDesc = prometheus.NewDesc(
         nil,
 )
 
-type unameCollector struct{}
+type unameCollector struct {
+        logger log.Logger
+}
 type uname struct {
         SysName    string
         Release    string
@@ -49,8 +52,8 @@ func init() {
 }
 
 // NewUnameCollector returns new unameCollector.
-func newUnameCollector() (Collector, error) {
-        return &unameCollector{}, nil
+func newUnameCollector(logger log.Logger) (Collector, error) {
+        return &unameCollector{logger}, nil
 }
 
 func (c *unameCollector) Update(ch chan<- prometheus.Metric) error {
diff --git a/collector/vmstat_linux.go b/collector/vmstat_linux.go
index 50268dd..605c38a 100644
--- a/collector/vmstat_linux.go
+++ b/collector/vmstat_linux.go
@@ -23,6 +23,7 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -37,6 +38,7 @@ var (
 
 type vmStatCollector struct {
         fieldPattern *regexp.Regexp
+        logger       log.Logger
 }
 
 func init() {
@@ -44,10 +46,11 @@ func init() {
 }
 
 // NewvmStatCollector returns a new Collector exposing vmstat stats.
-func NewvmStatCollector() (Collector, error) {
+func NewvmStatCollector(logger log.Logger) (Collector, error) {
         pattern := regexp.MustCompile(*vmStatFields)
         return &vmStatCollector{
                 fieldPattern: pattern,
+                logger:       logger,
         }, nil
 }
 
diff --git a/collector/wifi_linux.go b/collector/wifi_linux.go
index 8e0d4ee..5a5a86c 100644
--- a/collector/wifi_linux.go
+++ b/collector/wifi_linux.go
@@ -20,9 +20,10 @@ import (
         "os"
         "path/filepath"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/mdlayher/wifi"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
         "gopkg.in/alecthomas/kingpin.v2"
 )
 
@@ -40,6 +41,8 @@ type wifiCollector struct {
         stationTransmitRetriesTotal  *prometheus.Desc
         stationTransmitFailedTotal   *prometheus.Desc
         stationBeaconLossTotal       *prometheus.Desc
+
+        logger log.Logger
 }
 
 var (
@@ -61,7 +64,7 @@ type wifiStater interface {
 }
 
 // NewWifiCollector returns a new Collector exposing Wifi statistics.
-func NewWifiCollector() (Collector, error) {
+func NewWifiCollector(logger log.Logger) (Collector, error) {
         const (
                 subsystem = "wifi"
         )
@@ -154,6 +157,7 @@ func NewWifiCollector() (Collector, error) {
                         labels,
                         nil,
                 ),
+                logger: logger,
         }, nil
 }
 
@@ -162,11 +166,11 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
         if err != nil {
                 // Cannot access wifi metrics, report no error.
                 if os.IsNotExist(err) {
-                        log.Debug("wifi collector metrics are not available for this system")
+                        level.Debug(c.logger).Log("msg", "wifi collector metrics are not available for this system")
                         return nil
                 }
                 if os.IsPermission(err) {
-                        log.Debug("wifi collector got permission denied when accessing metrics")
+                        level.Debug(c.logger).Log("msg", "wifi collector got permission denied when accessing metrics")
                         return nil
                 }
 
@@ -185,7 +189,7 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
                         continue
                 }
 
-                log.Debugf("probing wifi device %q with type %q", ifi.Name, ifi.Type)
+                level.Debug(c.logger).Log("msg", "probing wifi device with type", "wifi", ifi.Name, "type", ifi.Type)
 
                 ch <- prometheus.MustNewConstMetric(
                         c.interfaceFrequencyHertz,
@@ -203,7 +207,7 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
                 case err == nil:
                         c.updateBSSStats(ch, ifi.Name, bss)
                 case os.IsNotExist(err):
-                        log.Debugf("BSS information not found for wifi device %q", ifi.Name)
+                        level.Debug(c.logger).Log("msg", "BSS information not found for wifi device", "name", ifi.Name)
                 default:
                         return fmt.Errorf("failed to retrieve BSS for device %s: %v",
                                 ifi.Name, err)
@@ -216,7 +220,7 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
                                 c.updateStationStats(ch, ifi.Name, station)
                         }
                 case os.IsNotExist(err):
-                        log.Debugf("station information not found for wifi device %q", ifi.Name)
+                        level.Debug(c.logger).Log("msg", "station information not found for wifi device", "name", ifi.Name)
                 default:
                         return fmt.Errorf("failed to retrieve station info for device %q: %v",
                                 ifi.Name, err)
diff --git a/collector/xfs_linux.go b/collector/xfs_linux.go
index c92a48c..77824c5 100644
--- a/collector/xfs_linux.go
+++ b/collector/xfs_linux.go
@@ -16,13 +16,15 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/procfs/xfs"
 )
 
 // An xfsCollector is a Collector which gathers metrics from XFS filesystems.
 type xfsCollector struct {
-        fs xfs.FS
+        fs     xfs.FS
+        logger log.Logger
 }
 
 func init() {
@@ -30,14 +32,15 @@ func init() {
 }
 
 // NewXFSCollector returns a new Collector exposing XFS statistics.
-func NewXFSCollector() (Collector, error) {
+func NewXFSCollector(logger log.Logger) (Collector, error) {
         fs, err := xfs.NewFS(*procPath, *sysPath)
         if err != nil {
                 return nil, fmt.Errorf("failed to open sysfs: %w", err)
         }
 
         return &xfsCollector{
-                fs: fs,
+                fs:     fs,
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/zfs.go b/collector/zfs.go
index aa33688..093ded5 100644
--- a/collector/zfs.go
+++ b/collector/zfs.go
@@ -20,8 +20,9 @@ import (
         "errors"
         "strings"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 var errZFSNotAvailable = errors.New("ZFS / ZFS statistics are not available")
@@ -36,10 +37,11 @@ type zfsCollector struct {
         linuxProcpathBase string
         linuxZpoolIoPath  string
         linuxPathMap      map[string]string
+        logger            log.Logger
 }
 
 // NewZFSCollector returns a new Collector exposing ZFS statistics.
-func NewZFSCollector() (Collector, error) {
+func NewZFSCollector(logger log.Logger) (Collector, error) {
         return &zfsCollector{
                 linuxProcpathBase: "spl/kstat/zfs",
                 linuxZpoolIoPath:  "/*/io",
@@ -56,6 +58,7 @@ func NewZFSCollector() (Collector, error) {
                         "zfs_zfetch":      "zfetchstats",
                         "zfs_zil":         "zil",
                 },
+                logger: logger,
         }, nil
 }
 
@@ -63,7 +66,7 @@ func (c *zfsCollector) Update(ch chan<- prometheus.Metric) error {
         for subsystem := range c.linuxPathMap {
                 if err := c.updateZfsStats(subsystem, ch); err != nil {
                         if err == errZFSNotAvailable {
-                                log.Debug(err)
+                                level.Debug(c.logger).Log("err", err)
                                 // ZFS /proc files are added as new features to ZFS arrive, it is ok to continue
                                 continue
                         }
diff --git a/collector/zfs_freebsd.go b/collector/zfs_freebsd.go
index 18fcd24..a625bbc 100644
--- a/collector/zfs_freebsd.go
+++ b/collector/zfs_freebsd.go
@@ -16,11 +16,13 @@ package collector
 import (
         "fmt"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
 )
 
 type zfsCollector struct {
         sysctls []bsdSysctl
+        logger  log.Logger
 }
 
 const (
@@ -31,7 +33,7 @@ func init() {
         registerCollector("zfs", defaultEnabled, NewZfsCollector)
 }
 
-func NewZfsCollector() (Collector, error) {
+func NewZfsCollector(logger log.Logger) (Collector, error) {
         return &zfsCollector{
                 sysctls: []bsdSysctl{
                         {
@@ -238,6 +240,7 @@ func NewZfsCollector() (Collector, error) {
                                 valueType:   prometheus.CounterValue,
                         },
                 },
+                logger: logger,
         }, nil
 }
 
diff --git a/collector/zfs_linux.go b/collector/zfs_linux.go
index a964d50..aa27db8 100644
--- a/collector/zfs_linux.go
+++ b/collector/zfs_linux.go
@@ -22,8 +22,8 @@ import (
         "strconv"
         "strings"
 
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
-        "github.com/prometheus/common/log"
 )
 
 // constants from https://github.com/zfsonlinux/zfs/blob/master/lib/libspl/include/sys/kstat.h
@@ -45,7 +45,7 @@ func (c *zfsCollector) openProcFile(path string) (*os.File, error) {
                 // file not found error can occur if:
                 // 1. zfs module is not loaded
                 // 2. zfs version does not have the feature with metrics -- ok to ignore
-                log.Debugf("Cannot open %q for reading", procFilePath(path))
+                level.Debug(c.logger).Log("msg", "Cannot open file for reading", "path", procFilePath(path))
                 return nil, errZFSNotAvailable
         }
         return file, nil
@@ -77,7 +77,7 @@ func (c *zfsCollector) updatePoolStats(ch chan<- prometheus.Metric) error {
                 file, err := os.Open(zpoolPath)
                 if err != nil {
                         // this file should exist, but there is a race where an exporting pool can remove the files -- ok to ignore
-                        log.Debugf("Cannot open %q for reading", zpoolPath)
+                        level.Debug(c.logger).Log("msg", "Cannot open file for reading", "path", zpoolPath)
                         return errZFSNotAvailable
                 }
 
diff --git a/collector/zfs_solaris.go b/collector/zfs_solaris.go
index 5bf2235..bfda64f 100644
--- a/collector/zfs_solaris.go
+++ b/collector/zfs_solaris.go
@@ -18,6 +18,7 @@ package collector
 import (
         "strings"
 
+        "github.com/go-kit/kit/log"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/siebenmann/go-kstat"
 )
@@ -52,6 +53,7 @@ type zfsCollector struct {
         arcstatsSize                 *prometheus.Desc
         zfetchstatsHits              *prometheus.Desc
         zfetchstatsMisses            *prometheus.Desc
+        logger                       log.Logger
 }
 
 const (
@@ -62,7 +64,7 @@ func init() {
         registerCollector("zfs", defaultEnabled, NewZfsCollector)
 }
 
-func NewZfsCollector() (Collector, error) {
+func NewZfsCollector(logger log.Logger) (Collector, error) {
         return &zfsCollector{
                 abdstatsLinearCount: prometheus.NewDesc(
                         prometheus.BuildFQName(namespace, zfsCollectorSubsystem, "abdstats_linear_count_total"),
@@ -180,6 +182,7 @@ func NewZfsCollector() (Collector, error) {
                         prometheus.BuildFQName(namespace, zfsCollectorSubsystem, "zfetchstats_misses_total"),
                         "ZFS cache fetch misses", nil, nil,
                 ),
+                logger: logger,
         }, nil
 }
 
diff --git a/go.mod b/go.mod
index 078e3bb..a811337 100644
--- a/go.mod
+++ b/go.mod
@@ -4,9 +4,9 @@ require (
         github.com/beevik/ntp v0.2.0
         github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e
         github.com/ema/qdisc v0.0.0-20190904071900-b82c76788043
+        github.com/go-kit/kit v0.9.0
         github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968
         github.com/hodgesds/perf-utils v0.0.7
-        github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
         github.com/lufia/iostat v0.0.0-20170605150913-9f7362b77ad3
         github.com/mattn/go-xmlrpc v0.0.3
         github.com/mdlayher/genetlink v0.0.0-20190828143517-e35f2bf499b9 // indirect
diff --git a/go.sum b/go.sum
index 230ca21..810a854 100644
--- a/go.sum
+++ b/go.sum
@@ -20,9 +20,12 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/ema/qdisc v0.0.0-20190904071900-b82c76788043 h1:I3hLsM87FSASssIrIOGwJCio31dvLkvpYDKn2+r31ec=
 github.com/ema/qdisc v0.0.0-20190904071900-b82c76788043/go.mod h1:ix4kG2zvdUd8kEKSW0ZTr1XLks0epFpI4j745DXxlNE=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0 h1:wDJmvq38kDhkVxi50ni9ykkdUr1PKgqKOoi01fa0Mdk=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968 h1:s+PDl6lozQ+dEUtUtQnO7+A2iPG3sK1pI4liU+jxn90=
 github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
@@ -46,8 +49,7 @@ github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/lufia/iostat v0.0.0-20170605150913-9f7362b77ad3 h1:XGhvld9vIpj929Gri5ybjukYZeyZwKkFkqgATqBQiOs=
 github.com/lufia/iostat v0.0.0-20170605150913-9f7362b77ad3/go.mod h1:lRgtFVamD7L7GaXOSwBiuXMwU3Aicfn5h66LVs4u2SA=
diff --git a/node_exporter.go b/node_exporter.go
index b48170c..6e92cc3 100644
--- a/node_exporter.go
+++ b/node_exporter.go
@@ -15,13 +15,17 @@ package main
 
 import (
         "fmt"
+        "github.com/prometheus/common/promlog"
+        "github.com/prometheus/common/promlog/flag"
         "net/http"
         _ "net/http/pprof"
+        "os"
         "sort"
 
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
         "github.com/prometheus/client_golang/prometheus"
         "github.com/prometheus/client_golang/prometheus/promhttp"
-        "github.com/prometheus/common/log"
         "github.com/prometheus/common/version"
         "github.com/prometheus/node_exporter/collector"
         "github.com/prometheus/node_exporter/https"
@@ -38,13 +42,15 @@ type handler struct {
         exporterMetricsRegistry *prometheus.Registry
         includeExporterMetrics  bool
         maxRequests             int
+        logger                  log.Logger
 }
 
-func newHandler(includeExporterMetrics bool, maxRequests int) *handler {
+func newHandler(includeExporterMetrics bool, maxRequests int, logger log.Logger) *handler {
         h := &handler{
                 exporterMetricsRegistry: prometheus.NewRegistry(),
                 includeExporterMetrics:  includeExporterMetrics,
                 maxRequests:             maxRequests,
+                logger:                  logger,
         }
         if h.includeExporterMetrics {
                 h.exporterMetricsRegistry.MustRegister(
@@ -53,7 +59,7 @@ func newHandler(includeExporterMetrics bool, maxRequests int) *handler {
                 )
         }
         if innerHandler, err := h.innerHandler(); err != nil {
-                log.Fatalf("Couldn't create metrics handler: %s", err)
+                panic(fmt.Sprintf("Couldn't create metrics handler: %s", err))
         } else {
                 h.unfilteredHandler = innerHandler
         }
@@ -63,7 +69,7 @@ func newHandler(includeExporterMetrics bool, maxRequests int) *handler {
 // ServeHTTP implements http.Handler.
 func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
         filters := r.URL.Query()["collect[]"]
-        log.Debugln("collect query:", filters)
+        level.Debug(h.logger).Log("msg", "collect query:", "filters", filters)
 
         if len(filters) == 0 {
                 // No filters, use the prepared unfiltered handler.
@@ -73,7 +79,7 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
         // To serve filtered metrics, we create a filtering handler on the fly.
         filteredHandler, err := h.innerHandler(filters...)
         if err != nil {
-                log.Warnln("Couldn't create filtered metrics handler:", err)
+                level.Warn(h.logger).Log("msg", "Couldn't create filtered metrics handler:", "err", err)
                 w.WriteHeader(http.StatusBadRequest)
                 w.Write([]byte(fmt.Sprintf("Couldn't create filtered metrics handler: %s", err)))
                 return
@@ -81,13 +87,13 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
         filteredHandler.ServeHTTP(w, r)
 }
 
-// innerHandler is used to create buth the one unfiltered http.Handler to be
+// innerHandler is used to create both the one unfiltered http.Handler to be
 // wrapped by the outer handler and also the filtered handlers created on the
 // fly. The former is accomplished by calling innerHandler without any arguments
 // (in which case it will log all the collectors enabled via command-line
 // flags).
 func (h *handler) innerHandler(filters ...string) (http.Handler, error) {
-        nc, err := collector.NewNodeCollector(filters...)
+        nc, err := collector.NewNodeCollector(h.logger, filters...)
         if err != nil {
                 return nil, fmt.Errorf("couldn't create collector: %s", err)
         }
@@ -95,14 +101,14 @@ func (h *handler) innerHandler(filters ...string) (http.Handler, error) {
         // Only log the creation of an unfiltered handler, which should happen
         // only once upon startup.
         if len(filters) == 0 {
-                log.Infof("Enabled collectors:")
+                level.Info(h.logger).Log("msg", "Enabled collectors")
                 collectors := []string{}
                 for n := range nc.Collectors {
                         collectors = append(collectors, n)
                 }
                 sort.Strings(collectors)
-                for _, n := range collectors {
-                        log.Infof(" - %s", n)
+                for _, c := range collectors {
+                        level.Info(h.logger).Log("collector", c)
                 }
         }
 
@@ -114,7 +120,6 @@ func (h *handler) innerHandler(filters ...string) (http.Handler, error) {
         handler := promhttp.HandlerFor(
                 prometheus.Gatherers{h.exporterMetricsRegistry, r},
                 promhttp.HandlerOpts{
-                        ErrorLog:            log.NewErrorLogger(),
                         ErrorHandling:       promhttp.ContinueOnError,
                         MaxRequestsInFlight: h.maxRequests,
                         Registry:            h.exporterMetricsRegistry,
@@ -154,15 +159,17 @@ func main() {
                 ).Default("").String()
         )
 
-        log.AddFlags(kingpin.CommandLine)
+        promlogConfig := &promlog.Config{}
+        flag.AddFlags(kingpin.CommandLine, promlogConfig)
         kingpin.Version(version.Print("node_exporter"))
         kingpin.HelpFlag.Short('h')
         kingpin.Parse()
+        logger := promlog.New(promlogConfig)
 
-        log.Infoln("Starting node_exporter", version.Info())
-        log.Infoln("Build context", version.BuildContext())
+        level.Info(logger).Log("msg", "Starting node_exporter", "version", version.Info())
+        level.Info(logger).Log("msg", "Build context", "build_context", version.BuildContext())
 
-        http.Handle(*metricsPath, newHandler(!*disableExporterMetrics, *maxRequests))
+        http.Handle(*metricsPath, newHandler(!*disableExporterMetrics, *maxRequests, logger))
         http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
                 w.Write([]byte(`<html>
                         <head><title>Node Exporter</title></head>
@@ -173,9 +180,10 @@ func main() {
                         </html>`))
         })
 
-        log.Infoln("Listening on", *listenAddress)
+        level.Info(logger).Log("msg", "Listening on", "address", *listenAddress)
         server := &http.Server{Addr: *listenAddress}
         if err := https.Listen(server, *configFile); err != nil {
-                log.Fatal(err)
+                level.Error(logger).Log("err", err)
+                os.Exit(1)
         }
 }
diff --git a/scripts/errcheck_excludes.txt b/scripts/errcheck_excludes.txt
index 2cadaa5..ed0736f 100644
--- a/scripts/errcheck_excludes.txt
+++ b/scripts/errcheck_excludes.txt
@@ -1,2 +1,4 @@
 // Used in HTTP handlers, any error is handled by the server itself.
 (net/http.ResponseWriter).Write
+// Never check for logger errors.
+(github.com/go-kit/kit/log.Logger).Log
\ No newline at end of file
diff --git a/vendor/github.com/sirupsen/logrus/LICENSE b/vendor/github.com/go-kit/kit/LICENSE
index f090cb4..9d83342 100644
--- a/vendor/github.com/sirupsen/logrus/LICENSE
+++ b/vendor/github.com/go-kit/kit/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Simon Eskildsen
+Copyright (c) 2015 Peter Bourgon
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,14 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 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.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vendor/github.com/go-kit/kit/log/README.md b/vendor/github.com/go-kit/kit/log/README.md
new file mode 100644
index 0000000..a201a3d
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/README.md
@@ -0,0 +1,151 @@
+# package log
+
+`package log` provides a minimal interface for structured logging in services.
+It may be wrapped to encode conventions, enforce type-safety, provide leveled
+logging, and so on. It can be used for both typical application log events,
+and log-structured data streams.
+
+## Structured logging
+
+Structured logging is, basically, conceding to the reality that logs are
+_data_, and warrant some level of schematic rigor. Using a stricter,
+key/value-oriented message format for our logs, containing contextual and
+semantic information, makes it much easier to get insight into the
+operational activity of the systems we build. Consequently, `package log` is
+of the strong belief that "[the benefits of structured logging outweigh the
+minimal effort involved](https://www.thoughtworks.com/radar/techniques/structured-logging)".
+
+Migrating from unstructured to structured logging is probably a lot easier
+than you'd expect.
+
+```go
+// Unstructured
+log.Printf("HTTP server listening on %s", addr)
+
+// Structured
+logger.Log("transport", "HTTP", "addr", addr, "msg", "listening")
+```
+
+## Usage
+
+### Typical application logging
+
+```go
+w := log.NewSyncWriter(os.Stderr)
+logger := log.NewLogfmtLogger(w)
+logger.Log("question", "what is the meaning of life?", "answer", 42)
+
+// Output:
+// question="what is the meaning of life?" answer=42
+```
+
+### Contextual Loggers
+
+```go
+func main() {
+        var logger log.Logger
+        logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
+        logger = log.With(logger, "instance_id", 123)
+
+        logger.Log("msg", "starting")
+        NewWorker(log.With(logger, "component", "worker")).Run()
+        NewSlacker(log.With(logger, "component", "slacker")).Run()
+}
+
+// Output:
+// instance_id=123 msg=starting
+// instance_id=123 component=worker msg=running
+// instance_id=123 component=slacker msg=running
+```
+
+### Interact with stdlib logger
+
+Redirect stdlib logger to Go kit logger.
+
+```go
+import (
+        "os"
+        stdlog "log"
+        kitlog "github.com/go-kit/kit/log"
+)
+
+func main() {
+        logger := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout))
+        stdlog.SetOutput(kitlog.NewStdlibAdapter(logger))
+        stdlog.Print("I sure like pie")
+}
+
+// Output:
+// {"msg":"I sure like pie","ts":"2016/01/01 12:34:56"}
+```
+
+Or, if, for legacy reasons, you need to pipe all of your logging through the
+stdlib log package, you can redirect Go kit logger to the stdlib logger.
+
+```go
+logger := kitlog.NewLogfmtLogger(kitlog.StdlibWriter{})
+logger.Log("legacy", true, "msg", "at least it's something")
+
+// Output:
+// 2016/01/01 12:34:56 legacy=true msg="at least it's something"
+```
+
+### Timestamps and callers
+
+```go
+var logger log.Logger
+logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
+logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller)
+
+logger.Log("msg", "hello")
+
+// Output:
+// ts=2016-01-01T12:34:56Z caller=main.go:15 msg=hello
+```
+
+## Levels
+
+Log levels are supported via the [level package](https://godoc.org/github.com/go-kit/kit/log/level).
+
+## Supported output formats
+
+- [Logfmt](https://brandur.org/logfmt) ([see also](https://blog.codeship.com/logfmt-a-log-format-thats-easy-to-read-and-write))
+- JSON
+
+## Enhancements
+
+`package log` is centered on the one-method Logger interface.
+
+```go
+type Logger interface {
+        Log(keyvals ...interface{}) error
+}
+```
+
+This interface, and its supporting code like is the product of much iteration
+and evaluation. For more details on the evolution of the Logger interface,
+see [The Hunt for a Logger Interface](http://go-talks.appspot.com/github.com/ChrisHines/talks/structured-logging/structured-logging.slide#1),
+a talk by [Chris Hines](https://github.com/ChrisHines).
+Also, please see
+[#63](https://github.com/go-kit/kit/issues/63),
+[#76](https://github.com/go-kit/kit/pull/76),
+[#131](https://github.com/go-kit/kit/issues/131),
+[#157](https://github.com/go-kit/kit/pull/157),
+[#164](https://github.com/go-kit/kit/issues/164), and
+[#252](https://github.com/go-kit/kit/pull/252)
+to review historical conversations about package log and the Logger interface.
+
+Value-add packages and suggestions,
+like improvements to [the leveled logger](https://godoc.org/github.com/go-kit/kit/log/level),
+are of course welcome. Good proposals should
+
+- Be composable with [contextual loggers](https://godoc.org/github.com/go-kit/kit/log#With),
+- Not break the behavior of [log.Caller](https://godoc.org/github.com/go-kit/kit/log#Caller) in any wrapped contextual loggers, and
+- Be friendly to packages that accept only an unadorned log.Logger.
+
+## Benchmarks & comparisons
+
+There are a few Go logging benchmarks and comparisons that include Go kit's package log.
+
+- [imkira/go-loggers-bench](https://github.com/imkira/go-loggers-bench) includes kit/log
+- [uber-common/zap](https://github.com/uber-common/zap), a zero-alloc logging library, includes a comparison with kit/log
diff --git a/vendor/github.com/go-kit/kit/log/doc.go b/vendor/github.com/go-kit/kit/log/doc.go
new file mode 100644
index 0000000..918c0af
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/doc.go
@@ -0,0 +1,116 @@
+// Package log provides a structured logger.
+//
+// Structured logging produces logs easily consumed later by humans or
+// machines. Humans might be interested in debugging errors, or tracing
+// specific requests. Machines might be interested in counting interesting
+// events, or aggregating information for off-line processing. In both cases,
+// it is important that the log messages are structured and actionable.
+// Package log is designed to encourage both of these best practices.
+//
+// Basic Usage
+//
+// The fundamental interface is Logger. Loggers create log events from
+// key/value data. The Logger interface has a single method, Log, which
+// accepts a sequence of alternating key/value pairs, which this package names
+// keyvals.
+//
+//    type Logger interface {
+//        Log(keyvals ...interface{}) error
+//    }
+//
+// Here is an example of a function using a Logger to create log events.
+//
+//    func RunTask(task Task, logger log.Logger) string {
+//        logger.Log("taskID", task.ID, "event", "starting task")
+//        ...
+//        logger.Log("taskID", task.ID, "event", "task complete")
+//    }
+//
+// The keys in the above example are "taskID" and "event". The values are
+// task.ID, "starting task", and "task complete". Every key is followed
+// immediately by its value.
+//
+// Keys are usually plain strings. Values may be any type that has a sensible
+// encoding in the chosen log format. With structured logging it is a good
+// idea to log simple values without formatting them. This practice allows
+// the chosen logger to encode values in the most appropriate way.
+//
+// Contextual Loggers
+//
+// A contextual logger stores keyvals that it includes in all log events.
+// Building appropriate contextual loggers reduces repetition and aids
+// consistency in the resulting log output. With and WithPrefix add context to
+// a logger. We can use With to improve the RunTask example.
+//
+//    func RunTask(task Task, logger log.Logger) string {
+//        logger = log.With(logger, "taskID", task.ID)
+//        logger.Log("event", "starting task")
+//        ...
+//        taskHelper(task.Cmd, logger)
+//        ...
+//        logger.Log("event", "task complete")
+//    }
+//
+// The improved version emits the same log events as the original for the
+// first and last calls to Log. Passing the contextual logger to taskHelper
+// enables each log event created by taskHelper to include the task.ID even
+// though taskHelper does not have access to that value. Using contextual
+// loggers this way simplifies producing log output that enables tracing the
+// life cycle of individual tasks. (See the Contextual example for the full
+// code of the above snippet.)
+//
+// Dynamic Contextual Values
+//
+// A Valuer function stored in a contextual logger generates a new value each
+// time an event is logged. The Valuer example demonstrates how this feature
+// works.
+//
+// Valuers provide the basis for consistently logging timestamps and source
+// code location. The log package defines several valuers for that purpose.
+// See Timestamp, DefaultTimestamp, DefaultTimestampUTC, Caller, and
+// DefaultCaller. A common logger initialization sequence that ensures all log
+// entries contain a timestamp and source location looks like this:
+//
+//    logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
+//    logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller)
+//
+// Concurrent Safety
+//
+// Applications with multiple goroutines want each log event written to the
+// same logger to remain separate from other log events. Package log provides
+// two simple solutions for concurrent safe logging.
+//
+// NewSyncWriter wraps an io.Writer and serializes each call to its Write
+// method. Using a SyncWriter has the benefit that the smallest practical
+// portion of the logging logic is performed within a mutex, but it requires
+// the formatting Logger to make only one call to Write per log event.
+//
+// NewSyncLogger wraps any Logger and serializes each call to its Log method.
+// Using a SyncLogger has the benefit that it guarantees each log event is
+// handled atomically within the wrapped logger, but it typically serializes
+// both the formatting and output logic. Use a SyncLogger if the formatting
+// logger may perform multiple writes per log event.
+//
+// Error Handling
+//
+// This package relies on the practice of wrapping or decorating loggers with
+// other loggers to provide composable pieces of functionality. It also means
+// that Logger.Log must return an error because some
+// implementations—especially those that output log data to an io.Writer—may
+// encounter errors that cannot be handled locally. This in turn means that
+// Loggers that wrap other loggers should return errors from the wrapped
+// logger up the stack.
+//
+// Fortunately, the decorator pattern also provides a way to avoid the
+// necessity to check for errors every time an application calls Logger.Log.
+// An application required to panic whenever its Logger encounters
+// an error could initialize its logger as follows.
+//
+//    fmtlogger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
+//    logger := log.LoggerFunc(func(keyvals ...interface{}) error {
+//        if err := fmtlogger.Log(keyvals...); err != nil {
+//            panic(err)
+//        }
+//        return nil
+//    })
+package log
diff --git a/vendor/github.com/go-kit/kit/log/json_logger.go b/vendor/github.com/go-kit/kit/log/json_logger.go
new file mode 100644
index 0000000..66094b4
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/json_logger.go
@@ -0,0 +1,89 @@
+package log
+
+import (
+        "encoding"
+        "encoding/json"
+        "fmt"
+        "io"
+        "reflect"
+)
+
+type jsonLogger struct {
+        io.Writer
+}
+
+// NewJSONLogger returns a Logger that encodes keyvals to the Writer as a
+// single JSON object. Each log event produces no more than one call to
+// w.Write. The passed Writer must be safe for concurrent use by multiple
+// goroutines if the returned Logger will be used concurrently.
+func NewJSONLogger(w io.Writer) Logger {
+        return &jsonLogger{w}
+}
+
+func (l *jsonLogger) Log(keyvals ...interface{}) error {
+        n := (len(keyvals) + 1) / 2 // +1 to handle case when len is odd
+        m := make(map[string]interface{}, n)
+        for i := 0; i < len(keyvals); i += 2 {
+                k := keyvals[i]
+                var v interface{} = ErrMissingValue
+                if i+1 < len(keyvals) {
+                        v = keyvals[i+1]
+                }
+                merge(m, k, v)
+        }
+        return json.NewEncoder(l.Writer).Encode(m)
+}
+
+func merge(dst map[string]interface{}, k, v interface{}) {
+        var key string
+        switch x := k.(type) {
+        case string:
+                key = x
+        case fmt.Stringer:
+                key = safeString(x)
+        default:
+                key = fmt.Sprint(x)
+        }
+
+        // We want json.Marshaler and encoding.TextMarshaller to take priority over
+        // err.Error() and v.String(). But json.Marshall (called later) does that by
+        // default so we force a no-op if it's one of those 2 case.
+        switch x := v.(type) {
+        case json.Marshaler:
+        case encoding.TextMarshaler:
+        case error:
+                v = safeError(x)
+        case fmt.Stringer:
+                v = safeString(x)
+        }
+
+        dst[key] = v
+}
+
+func safeString(str fmt.Stringer) (s string) {
+        defer func() {
+                if panicVal := recover(); panicVal != nil {
+                        if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() {
+                                s = "NULL"
+                        } else {
+                                panic(panicVal)
+                        }
+                }
+        }()
+        s = str.String()
+        return
+}
+
+func safeError(err error) (s interface{}) {
+        defer func() {
+                if panicVal := recover(); panicVal != nil {
+                        if v := reflect.ValueOf(err); v.Kind() == reflect.Ptr && v.IsNil() {
+                                s = nil
+                        } else {
+                                panic(panicVal)
+                        }
+                }
+        }()
+        s = err.Error()
+        return
+}
diff --git a/vendor/github.com/go-kit/kit/log/level/doc.go b/vendor/github.com/go-kit/kit/log/level/doc.go
new file mode 100644
index 0000000..505d307
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/level/doc.go
@@ -0,0 +1,22 @@
+// Package level implements leveled logging on top of Go kit's log package. To
+// use the level package, create a logger as per normal in your func main, and
+// wrap it with level.NewFilter.
+//
+//    var logger log.Logger
+//    logger = log.NewLogfmtLogger(os.Stderr)
+//    logger = level.NewFilter(logger, level.AllowInfo()) // <--
+//    logger = log.With(logger, "ts", log.DefaultTimestampUTC)
+//
+// Then, at the callsites, use one of the level.Debug, Info, Warn, or Error
+// helper methods to emit leveled log events.
+//
+//    logger.Log("foo", "bar") // as normal, no level
+//    level.Debug(logger).Log("request_id", reqID, "trace_data", trace.Get())
+//    if value > 100 {
+//        level.Error(logger).Log("value", value)
+//    }
+//
+// NewFilter allows precise control over what happens when a log event is
+// emitted without a level key, or if a squelched level is used. Check the
+// Option functions for details.
+package level
diff --git a/vendor/github.com/go-kit/kit/log/level/level.go b/vendor/github.com/go-kit/kit/log/level/level.go
new file mode 100644
index 0000000..fceafc4
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/level/level.go
@@ -0,0 +1,205 @@
+package level
+
+import "github.com/go-kit/kit/log"
+
+// Error returns a logger that includes a Key/ErrorValue pair.
+func Error(logger log.Logger) log.Logger {
+        return log.WithPrefix(logger, Key(), ErrorValue())
+}
+
+// Warn returns a logger that includes a Key/WarnValue pair.
+func Warn(logger log.Logger) log.Logger {
+        return log.WithPrefix(logger, Key(), WarnValue())
+}
+
+// Info returns a logger that includes a Key/InfoValue pair.
+func Info(logger log.Logger) log.Logger {
+        return log.WithPrefix(logger, Key(), InfoValue())
+}
+
+// Debug returns a logger that includes a Key/DebugValue pair.
+func Debug(logger log.Logger) log.Logger {
+        return log.WithPrefix(logger, Key(), DebugValue())
+}
+
+// NewFilter wraps next and implements level filtering. See the commentary on
+// the Option functions for a detailed description of how to configure levels.
+// If no options are provided, all leveled log events created with Debug,
+// Info, Warn or Error helper methods are squelched and non-leveled log
+// events are passed to next unmodified.
+func NewFilter(next log.Logger, options ...Option) log.Logger {
+        l := &logger{
+                next: next,
+        }
+        for _, option := range options {
+                option(l)
+        }
+        return l
+}
+
+type logger struct {
+        next           log.Logger
+        allowed        level
+        squelchNoLevel bool
+        errNotAllowed  error
+        errNoLevel     error
+}
+
+func (l *logger) Log(keyvals ...interface{}) error {
+        var hasLevel, levelAllowed bool
+        for i := 1; i < len(keyvals); i += 2 {
+                if v, ok := keyvals[i].(*levelValue); ok {
+                        hasLevel = true
+                        levelAllowed = l.allowed&v.level != 0
+                        break
+                }
+        }
+        if !hasLevel && l.squelchNoLevel {
+                return l.errNoLevel
+        }
+        if hasLevel && !levelAllowed {
+                return l.errNotAllowed
+        }
+        return l.next.Log(keyvals...)
+}
+
+// Option sets a parameter for the leveled logger.
+type Option func(*logger)
+
+// AllowAll is an alias for AllowDebug.
+func AllowAll() Option {
+        return AllowDebug()
+}
+
+// AllowDebug allows error, warn, info and debug level log events to pass.
+func AllowDebug() Option {
+        return allowed(levelError | levelWarn | levelInfo | levelDebug)
+}
+
+// AllowInfo allows error, warn and info level log events to pass.
+func AllowInfo() Option {
+        return allowed(levelError | levelWarn | levelInfo)
+}
+
+// AllowWarn allows error and warn level log events to pass.
+func AllowWarn() Option {
+        return allowed(levelError | levelWarn)
+}
+
+// AllowError allows only error level log events to pass.
+func AllowError() Option {
+        return allowed(levelError)
+}
+
+// AllowNone allows no leveled log events to pass.
+func AllowNone() Option {
+        return allowed(0)
+}
+
+func allowed(allowed level) Option {
+        return func(l *logger) { l.allowed = allowed }
+}
+
+// ErrNotAllowed sets the error to return from Log when it squelches a log
+// event disallowed by the configured Allow[Level] option. By default,
+// ErrNotAllowed is nil; in this case the log event is squelched with no
+// error.
+func ErrNotAllowed(err error) Option {
+        return func(l *logger) { l.errNotAllowed = err }
+}
+
+// SquelchNoLevel instructs Log to squelch log events with no level, so that
+// they don't proceed through to the wrapped logger. If SquelchNoLevel is set
+// to true and a log event is squelched in this way, the error value
+// configured with ErrNoLevel is returned to the caller.
+func SquelchNoLevel(squelch bool) Option {
+        return func(l *logger) { l.squelchNoLevel = squelch }
+}
+
+// ErrNoLevel sets the error to return from Log when it squelches a log event
+// with no level. By default, ErrNoLevel is nil; in this case the log event is
+// squelched with no error.
+func ErrNoLevel(err error) Option {
+        return func(l *logger) { l.errNoLevel = err }
+}
+
+// NewInjector wraps next and returns a logger that adds a Key/level pair to
+// the beginning of log events that don't already contain a level. In effect,
+// this gives a default level to logs without a level.
+func NewInjector(next log.Logger, level Value) log.Logger {
+        return &injector{
+                next:  next,
+                level: level,
+        }
+}
+
+type injector struct {
+        next  log.Logger
+        level interface{}
+}
+
+func (l *injector) Log(keyvals ...interface{}) error {
+        for i := 1; i < len(keyvals); i += 2 {
+                if _, ok := keyvals[i].(*levelValue); ok {
+                        return l.next.Log(keyvals...)
+                }
+        }
+        kvs := make([]interface{}, len(keyvals)+2)
+        kvs[0], kvs[1] = key, l.level
+        copy(kvs[2:], keyvals)
+        return l.next.Log(kvs...)
+}
+
+// Value is the interface that each of the canonical level values implement.
+// It contains unexported methods that prevent types from other packages from
+// implementing it and guaranteeing that NewFilter can distinguish the levels
+// defined in this package from all other values.
+type Value interface {
+        String() string
+        levelVal()
+}
+
+// Key returns the unique key added to log events by the loggers in this
+// package.
+func Key() interface{} { return key }
+
+// ErrorValue returns the unique value added to log events by Error.
+func ErrorValue() Value { return errorValue }
+
+// WarnValue returns the unique value added to log events by Warn.
+func WarnValue() Value { return warnValue }
+
+// InfoValue returns the unique value added to log events by Info.
+func InfoValue() Value { return infoValue }
+
+// DebugValue returns the unique value added to log events by Warn.
+func DebugValue() Value { return debugValue }
+
+var (
+        // key is of type interface{} so that it allocates once during package
+        // initialization and avoids allocating every time the value is added to a
+        // []interface{} later.
+        key interface{} = "level"
+
+        errorValue = &levelValue{level: levelError, name: "error"}
+        warnValue  = &levelValue{level: levelWarn, name: "warn"}
+        infoValue  = &levelValue{level: levelInfo, name: "info"}
+        debugValue = &levelValue{level: levelDebug, name: "debug"}
+)
+
+type level byte
+
+const (
+        levelDebug level = 1 << iota
+        levelInfo
+        levelWarn
+        levelError
+)
+
+type levelValue struct {
+        name string
+        level
+}
+
+func (v *levelValue) String() string { return v.name }
+func (v *levelValue) levelVal()      {}
diff --git a/vendor/github.com/go-kit/kit/log/log.go b/vendor/github.com/go-kit/kit/log/log.go
new file mode 100644
index 0000000..66a9e2f
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/log.go
@@ -0,0 +1,135 @@
+package log
+
+import "errors"
+
+// Logger is the fundamental interface for all log operations. Log creates a
+// log event from keyvals, a variadic sequence of alternating keys and values.
+// Implementations must be safe for concurrent use by multiple goroutines. In
+// particular, any implementation of Logger that appends to keyvals or
+// modifies or retains any of its elements must make a copy first.
+type Logger interface {
+        Log(keyvals ...interface{}) error
+}
+
+// ErrMissingValue is appended to keyvals slices with odd length to substitute
+// the missing value.
+var ErrMissingValue = errors.New("(MISSING)")
+
+// With returns a new contextual logger with keyvals prepended to those passed
+// to calls to Log. If logger is also a contextual logger created by With or
+// WithPrefix, keyvals is appended to the existing context.
+//
+// The returned Logger replaces all value elements (odd indexes) containing a
+// Valuer with their generated value for each call to its Log method.
+func With(logger Logger, keyvals ...interface{}) Logger {
+        if len(keyvals) == 0 {
+                return logger
+        }
+        l := newContext(logger)
+        kvs := append(l.keyvals, keyvals...)
+        if len(kvs)%2 != 0 {
+                kvs = append(kvs, ErrMissingValue)
+        }
+        return &context{
+                logger: l.logger,
+                // Limiting the capacity of the stored keyvals ensures that a new
+                // backing array is created if the slice must grow in Log or With.
+                // Using the extra capacity without copying risks a data race that
+                // would violate the Logger interface contract.
+                keyvals:   kvs[:len(kvs):len(kvs)],
+                hasValuer: l.hasValuer || containsValuer(keyvals),
+        }
+}
+
+// WithPrefix returns a new contextual logger with keyvals prepended to those
+// passed to calls to Log. If logger is also a contextual logger created by
+// With or WithPrefix, keyvals is prepended to the existing context.
+//
+// The returned Logger replaces all value elements (odd indexes) containing a
+// Valuer with their generated value for each call to its Log method.
+func WithPrefix(logger Logger, keyvals ...interface{}) Logger {
+        if len(keyvals) == 0 {
+                return logger
+        }
+        l := newContext(logger)
+        // Limiting the capacity of the stored keyvals ensures that a new
+        // backing array is created if the slice must grow in Log or With.
+        // Using the extra capacity without copying risks a data race that
+        // would violate the Logger interface contract.
+        n := len(l.keyvals) + len(keyvals)
+        if len(keyvals)%2 != 0 {
+                n++
+        }
+        kvs := make([]interface{}, 0, n)
+        kvs = append(kvs, keyvals...)
+        if len(kvs)%2 != 0 {
+                kvs = append(kvs, ErrMissingValue)
+        }
+        kvs = append(kvs, l.keyvals...)
+        return &context{
+                logger:    l.logger,
+                keyvals:   kvs,
+                hasValuer: l.hasValuer || containsValuer(keyvals),
+        }
+}
+
+// context is the Logger implementation returned by With and WithPrefix. It
+// wraps a Logger and holds keyvals that it includes in all log events. Its
+// Log method calls bindValues to generate values for each Valuer in the
+// context keyvals.
+//
+// A context must always have the same number of stack frames between calls to
+// its Log method and the eventual binding of Valuers to their value. This
+// requirement comes from the functional requirement to allow a context to
+// resolve application call site information for a Caller stored in the
+// context. To do this we must be able to predict the number of logging
+// functions on the stack when bindValues is called.
+//
+// Two implementation details provide the needed stack depth consistency.
+//
+//    1. newContext avoids introducing an additional layer when asked to
+//       wrap another context.
+//    2. With and WithPrefix avoid introducing an additional layer by
+//       returning a newly constructed context with a merged keyvals rather
+//       than simply wrapping the existing context.
+type context struct {
+        logger    Logger
+        keyvals   []interface{}
+        hasValuer bool
+}
+
+func newContext(logger Logger) *context {
+        if c, ok := logger.(*context); ok {
+                return c
+        }
+        return &context{logger: logger}
+}
+
+// Log replaces all value elements (odd indexes) containing a Valuer in the
+// stored context with their generated value, appends keyvals, and passes the
+// result to the wrapped Logger.
+func (l *context) Log(keyvals ...interface{}) error {
+        kvs := append(l.keyvals, keyvals...)
+        if len(kvs)%2 != 0 {
+                kvs = append(kvs, ErrMissingValue)
+        }
+        if l.hasValuer {
+                // If no keyvals were appended above then we must copy l.keyvals so
+                // that future log events will reevaluate the stored Valuers.
+                if len(keyvals) == 0 {
+                        kvs = append([]interface{}{}, l.keyvals...)
+                }
+                bindValues(kvs[:len(l.keyvals)])
+        }
+        return l.logger.Log(kvs...)
+}
+
+// LoggerFunc is an adapter to allow use of ordinary functions as Loggers. If
+// f is a function with the appropriate signature, LoggerFunc(f) is a Logger
+// object that calls f.
+type LoggerFunc func(...interface{}) error
+
+// Log implements Logger by calling f(keyvals...).
+func (f LoggerFunc) Log(keyvals ...interface{}) error {
+        return f(keyvals...)
+}
diff --git a/vendor/github.com/go-kit/kit/log/logfmt_logger.go b/vendor/github.com/go-kit/kit/log/logfmt_logger.go
new file mode 100644
index 0000000..a003052
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/logfmt_logger.go
@@ -0,0 +1,62 @@
+package log
+
+import (
+        "bytes"
+        "io"
+        "sync"
+
+        "github.com/go-logfmt/logfmt"
+)
+
+type logfmtEncoder struct {
+        *logfmt.Encoder
+        buf bytes.Buffer
+}
+
+func (l *logfmtEncoder) Reset() {
+        l.Encoder.Reset()
+        l.buf.Reset()
+}
+
+var logfmtEncoderPool = sync.Pool{
+        New: func() interface{} {
+                var enc logfmtEncoder
+                enc.Encoder = logfmt.NewEncoder(&enc.buf)
+                return &enc
+        },
+}
+
+type logfmtLogger struct {
+        w io.Writer
+}
+
+// NewLogfmtLogger returns a logger that encodes keyvals to the Writer in
+// logfmt format. Each log event produces no more than one call to w.Write.
+// The passed Writer must be safe for concurrent use by multiple goroutines if
+// the returned Logger will be used concurrently.
+func NewLogfmtLogger(w io.Writer) Logger {
+        return &logfmtLogger{w}
+}
+
+func (l logfmtLogger) Log(keyvals ...interface{}) error {
+        enc := logfmtEncoderPool.Get().(*logfmtEncoder)
+        enc.Reset()
+        defer logfmtEncoderPool.Put(enc)
+
+        if err := enc.EncodeKeyvals(keyvals...); err != nil {
+                return err
+        }
+
+        // Add newline to the end of the buffer
+        if err := enc.EndRecord(); err != nil {
+                return err
+        }
+
+        // The Logger interface requires implementations to be safe for concurrent
+        // use by multiple goroutines. For this implementation that means making
+        // only one call to l.w.Write() for each call to Log.
+        if _, err := l.w.Write(enc.buf.Bytes()); err != nil {
+                return err
+        }
+        return nil
+}
diff --git a/vendor/github.com/go-kit/kit/log/nop_logger.go b/vendor/github.com/go-kit/kit/log/nop_logger.go
new file mode 100644
index 0000000..1047d62
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/nop_logger.go
@@ -0,0 +1,8 @@
+package log
+
+type nopLogger struct{}
+
+// NewNopLogger returns a logger that doesn't do anything.
+func NewNopLogger() Logger { return nopLogger{} }
+
+func (nopLogger) Log(...interface{}) error { return nil }
diff --git a/vendor/github.com/go-kit/kit/log/stdlib.go b/vendor/github.com/go-kit/kit/log/stdlib.go
new file mode 100644
index 0000000..ff96b5d
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/stdlib.go
@@ -0,0 +1,116 @@
+package log
+
+import (
+        "io"
+        "log"
+        "regexp"
+        "strings"
+)
+
+// StdlibWriter implements io.Writer by invoking the stdlib log.Print. It's
+// designed to be passed to a Go kit logger as the writer, for cases where
+// it's necessary to redirect all Go kit log output to the stdlib logger.
+//
+// If you have any choice in the matter, you shouldn't use this. Prefer to
+// redirect the stdlib log to the Go kit logger via NewStdlibAdapter.
+type StdlibWriter struct{}
+
+// Write implements io.Writer.
+func (w StdlibWriter) Write(p []byte) (int, error) {
+        log.Print(strings.TrimSpace(string(p)))
+        return len(p), nil
+}
+
+// StdlibAdapter wraps a Logger and allows it to be passed to the stdlib
+// logger's SetOutput. It will extract date/timestamps, filenames, and
+// messages, and place them under relevant keys.
+type StdlibAdapter struct {
+        Logger
+        timestampKey string
+        fileKey      string
+        messageKey   string
+}
+
+// StdlibAdapterOption sets a parameter for the StdlibAdapter.
+type StdlibAdapterOption func(*StdlibAdapter)
+
+// TimestampKey sets the key for the timestamp field. By default, it's "ts".
+func TimestampKey(key string) StdlibAdapterOption {
+        return func(a *StdlibAdapter) { a.timestampKey = key }
+}
+
+// FileKey sets the key for the file and line field. By default, it's "caller".
+func FileKey(key string) StdlibAdapterOption {
+        return func(a *StdlibAdapter) { a.fileKey = key }
+}
+
+// MessageKey sets the key for the actual log message. By default, it's "msg".
+func MessageKey(key string) StdlibAdapterOption {
+        return func(a *StdlibAdapter) { a.messageKey = key }
+}
+
+// NewStdlibAdapter returns a new StdlibAdapter wrapper around the passed
+// logger. It's designed to be passed to log.SetOutput.
+func NewStdlibAdapter(logger Logger, options ...StdlibAdapterOption) io.Writer {
+        a := StdlibAdapter{
+                Logger:       logger,
+                timestampKey: "ts",
+                fileKey:      "caller",
+                messageKey:   "msg",
+        }
+        for _, option := range options {
+                option(&a)
+        }
+        return a
+}
+
+func (a StdlibAdapter) Write(p []byte) (int, error) {
+        result := subexps(p)
+        keyvals := []interface{}{}
+        var timestamp string
+        if date, ok := result["date"]; ok && date != "" {
+                timestamp = date
+        }
+        if time, ok := result["time"]; ok && time != "" {
+                if timestamp != "" {
+                        timestamp += " "
+                }
+                timestamp += time
+        }
+        if timestamp != "" {
+                keyvals = append(keyvals, a.timestampKey, timestamp)
+        }
+        if file, ok := result["file"]; ok && file != "" {
+                keyvals = append(keyvals, a.fileKey, file)
+        }
+        if msg, ok := result["msg"]; ok {
+                keyvals = append(keyvals, a.messageKey, msg)
+        }
+        if err := a.Logger.Log(keyvals...); err != nil {
+                return 0, err
+        }
+        return len(p), nil
+}
+
+const (
+        logRegexpDate = `(?P<date>[0-9]{4}/[0-9]{2}/[0-9]{2})?[ ]?`
+        logRegexpTime = `(?P<time>[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?)?[ ]?`
+        logRegexpFile = `(?P<file>.+?:[0-9]+)?`
+        logRegexpMsg  = `(: )?(?P<msg>.*)`
+)
+
+var (
+        logRegexp = regexp.MustCompile(logRegexpDate + logRegexpTime + logRegexpFile + logRegexpMsg)
+)
+
+func subexps(line []byte) map[string]string {
+        m := logRegexp.FindSubmatch(line)
+        if len(m) < len(logRegexp.SubexpNames()) {
+                return map[string]string{}
+        }
+        result := map[string]string{}
+        for i, name := range logRegexp.SubexpNames() {
+                result[name] = string(m[i])
+        }
+        return result
+}
diff --git a/vendor/github.com/go-kit/kit/log/sync.go b/vendor/github.com/go-kit/kit/log/sync.go
new file mode 100644
index 0000000..c07cdfa
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/sync.go
@@ -0,0 +1,116 @@
+package log
+
+import (
+        "io"
+        "sync"
+        "sync/atomic"
+)
+
+// SwapLogger wraps another logger that may be safely replaced while other
+// goroutines use the SwapLogger concurrently. The zero value for a SwapLogger
+// will discard all log events without error.
+//
+// SwapLogger serves well as a package global logger that can be changed by
+// importers.
+type SwapLogger struct {
+        logger atomic.Value
+}
+
+type loggerStruct struct {
+        Logger
+}
+
+// Log implements the Logger interface by forwarding keyvals to the currently
+// wrapped logger. It does not log anything if the wrapped logger is nil.
+func (l *SwapLogger) Log(keyvals ...interface{}) error {
+        s, ok := l.logger.Load().(loggerStruct)
+        if !ok || s.Logger == nil {
+                return nil
+        }
+        return s.Log(keyvals...)
+}
+
+// Swap replaces the currently wrapped logger with logger. Swap may be called
+// concurrently with calls to Log from other goroutines.
+func (l *SwapLogger) Swap(logger Logger) {
+        l.logger.Store(loggerStruct{logger})
+}
+
+// NewSyncWriter returns a new writer that is safe for concurrent use by
+// multiple goroutines. Writes to the returned writer are passed on to w. If
+// another write is already in progress, the calling goroutine blocks until
+// the writer is available.
+//
+// If w implements the following interface, so does the returned writer.
+//
+//    interface {
+//        Fd() uintptr
+//    }
+func NewSyncWriter(w io.Writer) io.Writer {
+        switch w := w.(type) {
+        case fdWriter:
+                return &fdSyncWriter{fdWriter: w}
+        default:
+                return &syncWriter{Writer: w}
+        }
+}
+
+// syncWriter synchronizes concurrent writes to an io.Writer.
+type syncWriter struct {
+        sync.Mutex
+        io.Writer
+}
+
+// Write writes p to the underlying io.Writer. If another write is already in
+// progress, the calling goroutine blocks until the syncWriter is available.
+func (w *syncWriter) Write(p []byte) (n int, err error) {
+        w.Lock()
+        n, err = w.Writer.Write(p)
+        w.Unlock()
+        return n, err
+}
+
+// fdWriter is an io.Writer that also has an Fd method. The most common
+// example of an fdWriter is an *os.File.
+type fdWriter interface {
+        io.Writer
+        Fd() uintptr
+}
+
+// fdSyncWriter synchronizes concurrent writes to an fdWriter.
+type fdSyncWriter struct {
+        sync.Mutex
+        fdWriter
+}
+
+// Write writes p to the underlying io.Writer. If another write is already in
+// progress, the calling goroutine blocks until the fdSyncWriter is available.
+func (w *fdSyncWriter) Write(p []byte) (n int, err error) {
+        w.Lock()
+        n, err = w.fdWriter.Write(p)
+        w.Unlock()
+        return n, err
+}
+
+// syncLogger provides concurrent safe logging for another Logger.
+type syncLogger struct {
+        mu     sync.Mutex
+        logger Logger
+}
+
+// NewSyncLogger returns a logger that synchronizes concurrent use of the
+// wrapped logger. When multiple goroutines use the SyncLogger concurrently
+// only one goroutine will be allowed to log to the wrapped logger at a time.
+// The other goroutines will block until the logger is available.
+func NewSyncLogger(logger Logger) Logger {
+        return &syncLogger{logger: logger}
+}
+
+// Log logs keyvals to the underlying Logger. If another log is already in
+// progress, the calling goroutine blocks until the syncLogger is available.
+func (l *syncLogger) Log(keyvals ...interface{}) error {
+        l.mu.Lock()
+        err := l.logger.Log(keyvals...)
+        l.mu.Unlock()
+        return err
+}
diff --git a/vendor/github.com/go-kit/kit/log/value.go b/vendor/github.com/go-kit/kit/log/value.go
new file mode 100644
index 0000000..1486f14
--- /dev/null
+++ b/vendor/github.com/go-kit/kit/log/value.go
@@ -0,0 +1,110 @@
+package log
+
+import (
+        "runtime"
+        "strconv"
+        "strings"
+        "time"
+)
+
+// A Valuer generates a log value. When passed to With or WithPrefix in a
+// value element (odd indexes), it represents a dynamic value which is re-
+// evaluated with each log event.
+type Valuer func() interface{}
+
+// bindValues replaces all value elements (odd indexes) containing a Valuer
+// with their generated value.
+func bindValues(keyvals []interface{}) {
+        for i := 1; i < len(keyvals); i += 2 {
+                if v, ok := keyvals[i].(Valuer); ok {
+                        keyvals[i] = v()
+                }
+        }
+}
+
+// containsValuer returns true if any of the value elements (odd indexes)
+// contain a Valuer.
+func containsValuer(keyvals []interface{}) bool {
+        for i := 1; i < len(keyvals); i += 2 {
+                if _, ok := keyvals[i].(Valuer); ok {
+                        return true
+                }
+        }
+        return false
+}
+
+// Timestamp returns a timestamp Valuer. It invokes the t function to get the
+// time; unless you are doing something tricky, pass time.Now.
+//
+// Most users will want to use DefaultTimestamp or DefaultTimestampUTC, which
+// are TimestampFormats that use the RFC3339Nano format.
+func Timestamp(t func() time.Time) Valuer {
+        return func() interface{} { return t() }
+}
+
+// TimestampFormat returns a timestamp Valuer with a custom time format. It
+// invokes the t function to get the time to format; unless you are doing
+// something tricky, pass time.Now. The layout string is passed to
+// Time.Format.
+//
+// Most users will want to use DefaultTimestamp or DefaultTimestampUTC, which
+// are TimestampFormats that use the RFC3339Nano format.
+func TimestampFormat(t func() time.Time, layout string) Valuer {
+        return func() interface{} {
+                return timeFormat{
+                        time:   t(),
+                        layout: layout,
+                }
+        }
+}
+
+// A timeFormat represents an instant in time and a layout used when
+// marshaling to a text format.
+type timeFormat struct {
+        time   time.Time
+        layout string
+}
+
+func (tf timeFormat) String() string {
+        return tf.time.Format(tf.layout)
+}
+
+// MarshalText implements encoding.TextMarshaller.
+func (tf timeFormat) MarshalText() (text []byte, err error) {
+        // The following code adapted from the standard library time.Time.Format
+        // method. Using the same undocumented magic constant to extend the size
+        // of the buffer as seen there.
+        b := make([]byte, 0, len(tf.layout)+10)
+        b = tf.time.AppendFormat(b, tf.layout)
+        return b, nil
+}
+
+// Caller returns a Valuer that returns a file and line from a specified depth
+// in the callstack. Users will probably want to use DefaultCaller.
+func Caller(depth int) Valuer {
+        return func() interface{} {
+                _, file, line, _ := runtime.Caller(depth)
+                idx := strings.LastIndexByte(file, '/')
+                // using idx+1 below handles both of following cases:
+                // idx == -1 because no "/" was found, or
+                // idx >= 0 and we want to start at the character after the found "/".
+                return file[idx+1:] + ":" + strconv.Itoa(line)
+        }
+}
+
+var (
+        // DefaultTimestamp is a Valuer that returns the current wallclock time,
+        // respecting time zones, when bound.
+        DefaultTimestamp = TimestampFormat(time.Now, time.RFC3339Nano)
+
+        // DefaultTimestampUTC is a Valuer that returns the current time in UTC
+        // when bound.
+        DefaultTimestampUTC = TimestampFormat(
+                func() time.Time { return time.Now().UTC() },
+                time.RFC3339Nano,
+        )
+
+        // DefaultCaller is a Valuer that returns the file and line where the Log
+        // method was invoked. It can only be used with log.With.
+        DefaultCaller = Caller(3)
+)
diff --git a/vendor/github.com/go-logfmt/logfmt/.gitignore b/vendor/github.com/go-logfmt/logfmt/.gitignore
new file mode 100644
index 0000000..320e53e
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/.gitignore
@@ -0,0 +1,4 @@
+_testdata/
+_testdata2/
+logfmt-fuzz.zip
+logfmt.test.exe
diff --git a/vendor/github.com/go-logfmt/logfmt/.travis.yml b/vendor/github.com/go-logfmt/logfmt/.travis.yml
new file mode 100644
index 0000000..25976da
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/.travis.yml
@@ -0,0 +1,16 @@
+language: go
+sudo: false
+go:
+  - "1.7.x"
+  - "1.8.x"
+  - "1.9.x"
+  - "1.10.x"
+  - "1.11.x"
+  - "tip"
+
+before_install:
+  - go get github.com/mattn/goveralls
+  - go get golang.org/x/tools/cmd/cover
+
+script:
+  - goveralls -service=travis-ci
diff --git a/vendor/github.com/go-logfmt/logfmt/CHANGELOG.md b/vendor/github.com/go-logfmt/logfmt/CHANGELOG.md
new file mode 100644
index 0000000..3455b8e
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/CHANGELOG.md
@@ -0,0 +1,41 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.4.0] - 2018-11-21
+
+### Added
+- Go module support by [@ChrisHines]
+- CHANGELOG by [@ChrisHines]
+
+### Changed
+- Drop invalid runes from keys instead of returning ErrInvalidKey by [@ChrisHines]
+- On panic while printing, attempt to print panic value by [@bboreham]
+
+## [0.3.0] - 2016-11-15
+### Added
+- Pool buffers for quoted strings and byte slices by [@nussjustin]
+### Fixed
+- Fuzz fix, quote invalid UTF-8 values by [@judwhite]
+
+## [0.2.0] - 2016-05-08
+### Added
+- Encoder.EncodeKeyvals by [@ChrisHines]
+
+## [0.1.0] - 2016-03-28
+### Added
+- Encoder by [@ChrisHines]
+- Decoder by [@ChrisHines]
+- MarshalKeyvals by [@ChrisHines]
+
+[0.4.0]: https://github.com/go-logfmt/logfmt/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/go-logfmt/logfmt/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/go-logfmt/logfmt/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/go-logfmt/logfmt/commits/v0.1.0
+
+[@ChrisHines]: https://github.com/ChrisHines
+[@bboreham]: https://github.com/bboreham
+[@judwhite]: https://github.com/judwhite
+[@nussjustin]: https://github.com/nussjustin
diff --git a/vendor/github.com/go-logfmt/logfmt/LICENSE b/vendor/github.com/go-logfmt/logfmt/LICENSE
new file mode 100644
index 0000000..c026508
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 go-logfmt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+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.
+
diff --git a/vendor/github.com/go-logfmt/logfmt/README.md b/vendor/github.com/go-logfmt/logfmt/README.md
new file mode 100644
index 0000000..3a8f10b
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/README.md
@@ -0,0 +1,33 @@
+[![GoDoc](https://godoc.org/github.com/go-logfmt/logfmt?status.svg)](https://godoc.org/github.com/go-logfmt/logfmt)
+[![Go Report Card](https://goreportcard.com/badge/go-logfmt/logfmt)](https://goreportcard.com/report/go-logfmt/logfmt)
+[![TravisCI](https://travis-ci.org/go-logfmt/logfmt.svg?branch=master)](https://travis-ci.org/go-logfmt/logfmt)
+[![Coverage Status](https://coveralls.io/repos/github/go-logfmt/logfmt/badge.svg?branch=master)](https://coveralls.io/github/go-logfmt/logfmt?branch=master)
+
+# logfmt
+
+Package logfmt implements utilities to marshal and unmarshal data in the [logfmt
+format](https://brandur.org/logfmt). It provides an API similar to
+[encoding/json](http://golang.org/pkg/encoding/json/) and
+[encoding/xml](http://golang.org/pkg/encoding/xml/).
+
+The logfmt format was first documented by Brandur Leach in [this
+article](https://brandur.org/logfmt). The format has not been formally
+standardized. The most authoritative public specification to date has been the
+documentation of a Go Language [package](http://godoc.org/github.com/kr/logfmt)
+written by Blake Mizerany and Keith Rarick.
+
+## Goals
+
+This project attempts to conform as closely as possible to the prior art, while
+also removing ambiguity where necessary to provide well behaved encoder and
+decoder implementations.
+
+## Non-goals
+
+This project does not attempt to formally standardize the logfmt format. In the
+event that logfmt is standardized this project would take conforming to the
+standard as a goal.
+
+## Versioning
+
+Package logfmt publishes releases via [semver](http://semver.org/) compatible Git tags prefixed with a single 'v'.
diff --git a/vendor/github.com/go-logfmt/logfmt/decode.go b/vendor/github.com/go-logfmt/logfmt/decode.go
new file mode 100644
index 0000000..04e0eff
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/decode.go
@@ -0,0 +1,237 @@
+package logfmt
+
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "io"
+        "unicode/utf8"
+)
+
+// A Decoder reads and decodes logfmt records from an input stream.
+type Decoder struct {
+        pos     int
+        key     []byte
+        value   []byte
+        lineNum int
+        s       *bufio.Scanner
+        err     error
+}
+
+// NewDecoder returns a new decoder that reads from r.
+//
+// The decoder introduces its own buffering and may read data from r beyond
+// the logfmt records requested.
+func NewDecoder(r io.Reader) *Decoder {
+        dec := &Decoder{
+                s: bufio.NewScanner(r),
+        }
+        return dec
+}
+
+// ScanRecord advances the Decoder to the next record, which can then be
+// parsed with the ScanKeyval method. It returns false when decoding stops,
+// either by reaching the end of the input or an error. After ScanRecord
+// returns false, the Err method will return any error that occurred during
+// decoding, except that if it was io.EOF, Err will return nil.
+func (dec *Decoder) ScanRecord() bool {
+        if dec.err != nil {
+                return false
+        }
+        if !dec.s.Scan() {
+                dec.err = dec.s.Err()
+                return false
+        }
+        dec.lineNum++
+        dec.pos = 0
+        return true
+}
+
+// ScanKeyval advances the Decoder to the next key/value pair of the current
+// record, which can then be retrieved with the Key and Value methods. It
+// returns false when decoding stops, either by reaching the end of the
+// current record or an error.
+func (dec *Decoder) ScanKeyval() bool {
+        dec.key, dec.value = nil, nil
+        if dec.err != nil {
+                return false
+        }
+
+        line := dec.s.Bytes()
+
+        // garbage
+        for p, c := range line[dec.pos:] {
+                if c > ' ' {
+                        dec.pos += p
+                        goto key
+                }
+        }
+        dec.pos = len(line)
+        return false
+
+key:
+        const invalidKeyError = "invalid key"
+
+        start, multibyte := dec.pos, false
+        for p, c := range line[dec.pos:] {
+                switch {
+                case c == '=':
+                        dec.pos += p
+                        if dec.pos > start {
+                                dec.key = line[start:dec.pos]
+                                if multibyte && bytes.IndexRune(dec.key, utf8.RuneError) != -1 {
+                                        dec.syntaxError(invalidKeyError)
+                                        return false
+                                }
+                        }
+                        if dec.key == nil {
+                                dec.unexpectedByte(c)
+                                return false
+                        }
+                        goto equal
+                case c == '"':
+                        dec.pos += p
+                        dec.unexpectedByte(c)
+                        return false
+                case c <= ' ':
+                        dec.pos += p
+                        if dec.pos > start {
+                                dec.key = line[start:dec.pos]
+                                if multibyte && bytes.IndexRune(dec.key, utf8.RuneError) != -1 {
+                                        dec.syntaxError(invalidKeyError)
+                                        return false
+                                }
+                        }
+                        return true
+                case c >= utf8.RuneSelf:
+                        multibyte = true
+                }
+        }
+        dec.pos = len(line)
+        if dec.pos > start {
+                dec.key = line[start:dec.pos]
+                if multibyte && bytes.IndexRune(dec.key, utf8.RuneError) != -1 {
+                        dec.syntaxError(invalidKeyError)
+                        return false
+                }
+        }
+        return true
+
+equal:
+        dec.pos++
+        if dec.pos >= len(line) {
+                return true
+        }
+        switch c := line[dec.pos]; {
+        case c <= ' ':
+                return true
+        case c == '"':
+                goto qvalue
+        }
+
+        // value
+        start = dec.pos
+        for p, c := range line[dec.pos:] {
+                switch {
+                case c == '=' || c == '"':
+                        dec.pos += p
+                        dec.unexpectedByte(c)
+                        return false
+                case c <= ' ':
+                        dec.pos += p
+                        if dec.pos > start {
+                                dec.value = line[start:dec.pos]
+                        }
+                        return true
+                }
+        }
+        dec.pos = len(line)
+        if dec.pos > start {
+                dec.value = line[start:dec.pos]
+        }
+        return true
+
+qvalue:
+        const (
+                untermQuote  = "unterminated quoted value"
+                invalidQuote = "invalid quoted value"
+        )
+
+        hasEsc, esc := false, false
+        start = dec.pos
+        for p, c := range line[dec.pos+1:] {
+                switch {
+                case esc:
+                        esc = false
+                case c == '\\':
+                        hasEsc, esc = true, true
+                case c == '"':
+                        dec.pos += p + 2
+                        if hasEsc {
+                                v, ok := unquoteBytes(line[start:dec.pos])
+                                if !ok {
+                                        dec.syntaxError(invalidQuote)
+                                        return false
+                                }
+                                dec.value = v
+                        } else {
+                                start++
+                                end := dec.pos - 1
+                                if end > start {
+                                        dec.value = line[start:end]
+                                }
+                        }
+                        return true
+                }
+        }
+        dec.pos = len(line)
+        dec.syntaxError(untermQuote)
+        return false
+}
+
+// Key returns the most recent key found by a call to ScanKeyval. The returned
+// slice may point to internal buffers and is only valid until the next call
+// to ScanRecord.  It does no allocation.
+func (dec *Decoder) Key() []byte {
+        return dec.key
+}
+
+// Value returns the most recent value found by a call to ScanKeyval. The
+// returned slice may point to internal buffers and is only valid until the
+// next call to ScanRecord.  It does no allocation when the value has no
+// escape sequences.
+func (dec *Decoder) Value() []byte {
+        return dec.value
+}
+
+// Err returns the first non-EOF error that was encountered by the Scanner.
+func (dec *Decoder) Err() error {
+        return dec.err
+}
+
+func (dec *Decoder) syntaxError(msg string) {
+        dec.err = &SyntaxError{
+                Msg:  msg,
+                Line: dec.lineNum,
+                Pos:  dec.pos + 1,
+        }
+}
+
+func (dec *Decoder) unexpectedByte(c byte) {
+        dec.err = &SyntaxError{
+                Msg:  fmt.Sprintf("unexpected %q", c),
+                Line: dec.lineNum,
+                Pos:  dec.pos + 1,
+        }
+}
+
+// A SyntaxError represents a syntax error in the logfmt input stream.
+type SyntaxError struct {
+        Msg  string
+        Line int
+        Pos  int
+}
+
+func (e *SyntaxError) Error() string {
+        return fmt.Sprintf("logfmt syntax error at pos %d on line %d: %s", e.Pos, e.Line, e.Msg)
+}
diff --git a/vendor/github.com/go-logfmt/logfmt/doc.go b/vendor/github.com/go-logfmt/logfmt/doc.go
new file mode 100644
index 0000000..378e9ad
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/doc.go
@@ -0,0 +1,6 @@
+// Package logfmt implements utilities to marshal and unmarshal data in the
+// logfmt format. The logfmt format records key/value pairs in a way that
+// balances readability for humans and simplicity of computer parsing. It is
+// most commonly used as a more human friendly alternative to JSON for
+// structured logging.
+package logfmt
diff --git a/vendor/github.com/go-logfmt/logfmt/encode.go b/vendor/github.com/go-logfmt/logfmt/encode.go
new file mode 100644
index 0000000..4ea9d23
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/encode.go
@@ -0,0 +1,322 @@
+package logfmt
+
+import (
+        "bytes"
+        "encoding"
+        "errors"
+        "fmt"
+        "io"
+        "reflect"
+        "strings"
+        "unicode/utf8"
+)
+
+// MarshalKeyvals returns the logfmt encoding of keyvals, a variadic sequence
+// of alternating keys and values.
+func MarshalKeyvals(keyvals ...interface{}) ([]byte, error) {
+        buf := &bytes.Buffer{}
+        if err := NewEncoder(buf).EncodeKeyvals(keyvals...); err != nil {
+                return nil, err
+        }
+        return buf.Bytes(), nil
+}
+
+// An Encoder writes logfmt data to an output stream.
+type Encoder struct {
+        w       io.Writer
+        scratch bytes.Buffer
+        needSep bool
+}
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+        return &Encoder{
+                w: w,
+        }
+}
+
+var (
+        space   = []byte(" ")
+        equals  = []byte("=")
+        newline = []byte("\n")
+        null    = []byte("null")
+)
+
+// EncodeKeyval writes the logfmt encoding of key and value to the stream. A
+// single space is written before the second and subsequent keys in a record.
+// Nothing is written if a non-nil error is returned.
+func (enc *Encoder) EncodeKeyval(key, value interface{}) error {
+        enc.scratch.Reset()
+        if enc.needSep {
+                if _, err := enc.scratch.Write(space); err != nil {
+                        return err
+                }
+        }
+        if err := writeKey(&enc.scratch, key); err != nil {
+                return err
+        }
+        if _, err := enc.scratch.Write(equals); err != nil {
+                return err
+        }
+        if err := writeValue(&enc.scratch, value); err != nil {
+                return err
+        }
+        _, err := enc.w.Write(enc.scratch.Bytes())
+        enc.needSep = true
+        return err
+}
+
+// EncodeKeyvals writes the logfmt encoding of keyvals to the stream. Keyvals
+// is a variadic sequence of alternating keys and values. Keys of unsupported
+// type are skipped along with their corresponding value. Values of
+// unsupported type or that cause a MarshalerError are replaced by their error
+// but do not cause EncodeKeyvals to return an error. If a non-nil error is
+// returned some key/value pairs may not have be written.
+func (enc *Encoder) EncodeKeyvals(keyvals ...interface{}) error {
+        if len(keyvals) == 0 {
+                return nil
+        }
+        if len(keyvals)%2 == 1 {
+                keyvals = append(keyvals, nil)
+        }
+        for i := 0; i < len(keyvals); i += 2 {
+                k, v := keyvals[i], keyvals[i+1]
+                err := enc.EncodeKeyval(k, v)
+                if err == ErrUnsupportedKeyType {
+                        continue
+                }
+                if _, ok := err.(*MarshalerError); ok || err == ErrUnsupportedValueType {
+                        v = err
+                        err = enc.EncodeKeyval(k, v)
+                }
+                if err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+// MarshalerError represents an error encountered while marshaling a value.
+type MarshalerError struct {
+        Type reflect.Type
+        Err  error
+}
+
+func (e *MarshalerError) Error() string {
+        return "error marshaling value of type " + e.Type.String() + ": " + e.Err.Error()
+}
+
+// ErrNilKey is returned by Marshal functions and Encoder methods if a key is
+// a nil interface or pointer value.
+var ErrNilKey = errors.New("nil key")
+
+// ErrInvalidKey is returned by Marshal functions and Encoder methods if, after
+// dropping invalid runes, a key is empty.
+var ErrInvalidKey = errors.New("invalid key")
+
+// ErrUnsupportedKeyType is returned by Encoder methods if a key has an
+// unsupported type.
+var ErrUnsupportedKeyType = errors.New("unsupported key type")
+
+// ErrUnsupportedValueType is returned by Encoder methods if a value has an
+// unsupported type.
+var ErrUnsupportedValueType = errors.New("unsupported value type")
+
+func writeKey(w io.Writer, key interface{}) error {
+        if key == nil {
+                return ErrNilKey
+        }
+
+        switch k := key.(type) {
+        case string:
+                return writeStringKey(w, k)
+        case []byte:
+                if k == nil {
+                        return ErrNilKey
+                }
+                return writeBytesKey(w, k)
+        case encoding.TextMarshaler:
+                kb, err := safeMarshal(k)
+                if err != nil {
+                        return err
+                }
+                if kb == nil {
+                        return ErrNilKey
+                }
+                return writeBytesKey(w, kb)
+        case fmt.Stringer:
+                ks, ok := safeString(k)
+                if !ok {
+                        return ErrNilKey
+                }
+                return writeStringKey(w, ks)
+        default:
+                rkey := reflect.ValueOf(key)
+                switch rkey.Kind() {
+                case reflect.Array, reflect.Chan, reflect.Func, reflect.Map, reflect.Slice, reflect.Struct:
+                        return ErrUnsupportedKeyType
+                case reflect.Ptr:
+                        if rkey.IsNil() {
+                                return ErrNilKey
+                        }
+                        return writeKey(w, rkey.Elem().Interface())
+                }
+                return writeStringKey(w, fmt.Sprint(k))
+        }
+}
+
+// keyRuneFilter returns r for all valid key runes, and -1 for all invalid key
+// runes. When used as the mapping function for strings.Map and bytes.Map
+// functions it causes them to remove invalid key runes from strings or byte
+// slices respectively.
+func keyRuneFilter(r rune) rune {
+        if r <= ' ' || r == '=' || r == '"' || r == utf8.RuneError {
+                return -1
+        }
+        return r
+}
+
+func writeStringKey(w io.Writer, key string) error {
+        k := strings.Map(keyRuneFilter, key)
+        if k == "" {
+                return ErrInvalidKey
+        }
+        _, err := io.WriteString(w, k)
+        return err
+}
+
+func writeBytesKey(w io.Writer, key []byte) error {
+        k := bytes.Map(keyRuneFilter, key)
+        if len(k) == 0 {
+                return ErrInvalidKey
+        }
+        _, err := w.Write(k)
+        return err
+}
+
+func writeValue(w io.Writer, value interface{}) error {
+        switch v := value.(type) {
+        case nil:
+                return writeBytesValue(w, null)
+        case string:
+                return writeStringValue(w, v, true)
+        case []byte:
+                return writeBytesValue(w, v)
+        case encoding.TextMarshaler:
+                vb, err := safeMarshal(v)
+                if err != nil {
+                        return err
+                }
+                if vb == nil {
+                        vb = null
+                }
+                return writeBytesValue(w, vb)
+        case error:
+                se, ok := safeError(v)
+                return writeStringValue(w, se, ok)
+        case fmt.Stringer:
+                ss, ok := safeString(v)
+                return writeStringValue(w, ss, ok)
+        default:
+                rvalue := reflect.ValueOf(value)
+                switch rvalue.Kind() {
+                case reflect.Array, reflect.Chan, reflect.Func, reflect.Map, reflect.Slice, reflect.Struct:
+                        return ErrUnsupportedValueType
+                case reflect.Ptr:
+                        if rvalue.IsNil() {
+                                return writeBytesValue(w, null)
+                        }
+                        return writeValue(w, rvalue.Elem().Interface())
+                }
+                return writeStringValue(w, fmt.Sprint(v), true)
+        }
+}
+
+func needsQuotedValueRune(r rune) bool {
+        return r <= ' ' || r == '=' || r == '"' || r == utf8.RuneError
+}
+
+func writeStringValue(w io.Writer, value string, ok bool) error {
+        var err error
+        if ok && value == "null" {
+                _, err = io.WriteString(w, `"null"`)
+        } else if strings.IndexFunc(value, needsQuotedValueRune) != -1 {
+                _, err = writeQuotedString(w, value)
+        } else {
+                _, err = io.WriteString(w, value)
+        }
+        return err
+}
+
+func writeBytesValue(w io.Writer, value []byte) error {
+        var err error
+        if bytes.IndexFunc(value, needsQuotedValueRune) != -1 {
+                _, err = writeQuotedBytes(w, value)
+        } else {
+                _, err = w.Write(value)
+        }
+        return err
+}
+
+// EndRecord writes a newline character to the stream and resets the encoder
+// to the beginning of a new record.
+func (enc *Encoder) EndRecord() error {
+        _, err := enc.w.Write(newline)
+        if err == nil {
+                enc.needSep = false
+        }
+        return err
+}
+
+// Reset resets the encoder to the beginning of a new record.
+func (enc *Encoder) Reset() {
+        enc.needSep = false
+}
+
+func safeError(err error) (s string, ok bool) {
+        defer func() {
+                if panicVal := recover(); panicVal != nil {
+                        if v := reflect.ValueOf(err); v.Kind() == reflect.Ptr && v.IsNil() {
+                                s, ok = "null", false
+                        } else {
+                                s, ok = fmt.Sprintf("PANIC:%v", panicVal), false
+                        }
+                }
+        }()
+        s, ok = err.Error(), true
+        return
+}
+
+func safeString(str fmt.Stringer) (s string, ok bool) {
+        defer func() {
+                if panicVal := recover(); panicVal != nil {
+                        if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() {
+                                s, ok = "null", false
+                        } else {
+                                s, ok = fmt.Sprintf("PANIC:%v", panicVal), true
+                        }
+                }
+        }()
+        s, ok = str.String(), true
+        return
+}
+
+func safeMarshal(tm encoding.TextMarshaler) (b []byte, err error) {
+        defer func() {
+                if panicVal := recover(); panicVal != nil {
+                        if v := reflect.ValueOf(tm); v.Kind() == reflect.Ptr && v.IsNil() {
+                                b, err = nil, nil
+                        } else {
+                                b, err = nil, fmt.Errorf("panic when marshalling: %s", panicVal)
+                        }
+                }
+        }()
+        b, err = tm.MarshalText()
+        if err != nil {
+                return nil, &MarshalerError{
+                        Type: reflect.TypeOf(tm),
+                        Err:  err,
+                }
+        }
+        return
+}
diff --git a/vendor/github.com/go-logfmt/logfmt/fuzz.go b/vendor/github.com/go-logfmt/logfmt/fuzz.go
new file mode 100644
index 0000000..6553b35
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/fuzz.go
@@ -0,0 +1,126 @@
+// +build gofuzz
+
+package logfmt
+
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "io"
+        "reflect"
+
+        kr "github.com/kr/logfmt"
+)
+
+// Fuzz checks reserialized data matches
+func Fuzz(data []byte) int {
+        parsed, err := parse(data)
+        if err != nil {
+                return 0
+        }
+        var w1 bytes.Buffer
+        if err = write(parsed, &w1); err != nil {
+                panic(err)
+        }
+        parsed, err = parse(w1.Bytes())
+        if err != nil {
+                panic(err)
+        }
+        var w2 bytes.Buffer
+        if err = write(parsed, &w2); err != nil {
+                panic(err)
+        }
+        if !bytes.Equal(w1.Bytes(), w2.Bytes()) {
+                panic(fmt.Sprintf("reserialized data does not match:\n%q\n%q\n", w1.Bytes(), w2.Bytes()))
+        }
+        return 1
+}
+
+// FuzzVsKR checks go-logfmt/logfmt against kr/logfmt
+func FuzzVsKR(data []byte) int {
+        parsed, err := parse(data)
+        parsedKR, errKR := parseKR(data)
+
+        // github.com/go-logfmt/logfmt is a stricter parser. It returns errors for
+        // more inputs than github.com/kr/logfmt. Ignore any inputs that have a
+        // stict error.
+        if err != nil {
+                return 0
+        }
+
+        // Fail if the more forgiving parser finds an error not found by the
+        // stricter parser.
+        if errKR != nil {
+                panic(fmt.Sprintf("unmatched error: %v", errKR))
+        }
+
+        if !reflect.DeepEqual(parsed, parsedKR) {
+                panic(fmt.Sprintf("parsers disagree:\n%+v\n%+v\n", parsed, parsedKR))
+        }
+        return 1
+}
+
+type kv struct {
+        k, v []byte
+}
+
+func parse(data []byte) ([][]kv, error) {
+        var got [][]kv
+        dec := NewDecoder(bytes.NewReader(data))
+        for dec.ScanRecord() {
+                var kvs []kv
+                for dec.ScanKeyval() {
+                        kvs = append(kvs, kv{dec.Key(), dec.Value()})
+                }
+                got = append(got, kvs)
+        }
+        return got, dec.Err()
+}
+
+func parseKR(data []byte) ([][]kv, error) {
+        var (
+                s   = bufio.NewScanner(bytes.NewReader(data))
+                err error
+                h   saveHandler
+                got [][]kv
+        )
+        for err == nil && s.Scan() {
+                h.kvs = nil
+                err = kr.Unmarshal(s.Bytes(), &h)
+                got = append(got, h.kvs)
+        }
+        if err == nil {
+                err = s.Err()
+        }
+        return got, err
+}
+
+type saveHandler struct {
+        kvs []kv
+}
+
+func (h *saveHandler) HandleLogfmt(key, val []byte) error {
+        if len(key) == 0 {
+                key = nil
+        }
+        if len(val) == 0 {
+                val = nil
+        }
+        h.kvs = append(h.kvs, kv{key, val})
+        return nil
+}
+
+func write(recs [][]kv, w io.Writer) error {
+        enc := NewEncoder(w)
+        for _, rec := range recs {
+                for _, f := range rec {
+                        if err := enc.EncodeKeyval(f.k, f.v); err != nil {
+                                return err
+                        }
+                }
+                if err := enc.EndRecord(); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
diff --git a/vendor/github.com/go-logfmt/logfmt/go.mod b/vendor/github.com/go-logfmt/logfmt/go.mod
new file mode 100644
index 0000000..63d50f0
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/go.mod
@@ -0,0 +1,3 @@
+module github.com/go-logfmt/logfmt
+
+require github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515
diff --git a/vendor/github.com/go-logfmt/logfmt/go.sum b/vendor/github.com/go-logfmt/logfmt/go.sum
new file mode 100644
index 0000000..d0cdc16
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/go.sum
@@ -0,0 +1,2 @@
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
diff --git a/vendor/github.com/go-logfmt/logfmt/jsonstring.go b/vendor/github.com/go-logfmt/logfmt/jsonstring.go
new file mode 100644
index 0000000..030ac85
--- /dev/null
+++ b/vendor/github.com/go-logfmt/logfmt/jsonstring.go
@@ -0,0 +1,277 @@
+package logfmt
+
+import (
+        "bytes"
+        "io"
+        "strconv"
+        "sync"
+        "unicode"
+        "unicode/utf16"
+        "unicode/utf8"
+)
+
+// Taken from Go's encoding/json and modified for use here.
+
+// Copyright 2010 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.
+
+var hex = "0123456789abcdef"
+
+var bufferPool = sync.Pool{
+        New: func() interface{} {
+                return &bytes.Buffer{}
+        },
+}
+
+func getBuffer() *bytes.Buffer {
+        return bufferPool.Get().(*bytes.Buffer)
+}
+
+func poolBuffer(buf *bytes.Buffer) {
+        buf.Reset()
+        bufferPool.Put(buf)
+}
+
+// NOTE: keep in sync with writeQuotedBytes below.
+func writeQuotedString(w io.Writer, s string) (int, error) {
+        buf := getBuffer()
+        buf.WriteByte('"')
+        start := 0
+        for i := 0; i < len(s); {
+                if b := s[i]; b < utf8.RuneSelf {
+                        if 0x20 <= b && b != '\\' && b != '"' {
+                                i++
+                                continue
+                        }
+                        if start < i {
+                                buf.WriteString(s[start:i])
+                        }
+                        switch b {
+                        case '\\', '"':
+                                buf.WriteByte('\\')
+                                buf.WriteByte(b)
+                        case '\n':
+                                buf.WriteByte('\\')
+                                buf.WriteByte('n')
+                        case '\r':
+                                buf.WriteByte('\\')
+                                buf.WriteByte('r')
+                        case '\t':
+                                buf.WriteByte('\\')
+                                buf.WriteByte('t')
+                        default:
+                                // This encodes bytes < 0x20 except for \n, \r, and \t.
+                                buf.WriteString(`\u00`)
+                                buf.WriteByte(hex[b>>4])
+                                buf.WriteByte(hex[b&0xF])
+                        }
+                        i++
+                        start = i
+                        continue
+                }
+                c, size := utf8.DecodeRuneInString(s[i:])
+                if c == utf8.RuneError {
+                        if start < i {
+                                buf.WriteString(s[start:i])
+                        }
+                        buf.WriteString(`\ufffd`)
+                        i += size
+                        start = i
+                        continue
+                }
+                i += size
+        }
+        if start < len(s) {
+                buf.WriteString(s[start:])
+        }
+        buf.WriteByte('"')
+        n, err := w.Write(buf.Bytes())
+        poolBuffer(buf)
+        return n, err
+}
+
+// NOTE: keep in sync with writeQuoteString above.
+func writeQuotedBytes(w io.Writer, s []byte) (int, error) {
+        buf := getBuffer()
+        buf.WriteByte('"')
+        start := 0
+        for i := 0; i < len(s); {
+                if b := s[i]; b < utf8.RuneSelf {
+                        if 0x20 <= b && b != '\\' && b != '"' {
+                                i++
+                                continue
+                        }
+                        if start < i {
+                                buf.Write(s[start:i])
+                        }
+                        switch b {
+                        case '\\', '"':
+                                buf.WriteByte('\\')
+                                buf.WriteByte(b)
+                        case '\n':
+                                buf.WriteByte('\\')
+                                buf.WriteByte('n')
+                        case '\r':
+                                buf.WriteByte('\\')
+                                buf.WriteByte('r')
+                        case '\t':
+                                buf.WriteByte('\\')
+                                buf.WriteByte('t')
+                        default:
+                                // This encodes bytes < 0x20 except for \n, \r, and \t.
+                                buf.WriteString(`\u00`)
+                                buf.WriteByte(hex[b>>4])
+                                buf.WriteByte(hex[b&0xF])
+                        }
+                        i++
+                        start = i
+                        continue
+                }
+                c, size := utf8.DecodeRune(s[i:])
+                if c == utf8.RuneError {
+                        if start < i {
+                                buf.Write(s[start:i])
+                        }
+                        buf.WriteString(`\ufffd`)
+                        i += size
+                        start = i
+                        continue
+                }
+                i += size
+        }
+        if start < len(s) {
+                buf.Write(s[start:])
+        }
+        buf.WriteByte('"')
+        n, err := w.Write(buf.Bytes())
+        poolBuffer(buf)
+        return n, err
+}
+
+// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
+// or it returns -1.
+func getu4(s []byte) rune {
+        if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
+                return -1
+        }
+        r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
+        if err != nil {
+                return -1
+        }
+        return rune(r)
+}
+
+func unquoteBytes(s []byte) (t []byte, ok bool) {
+        if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
+                return
+        }
+        s = s[1 : len(s)-1]
+
+        // Check for unusual characters. If there are none,
+        // then no unquoting is needed, so return a slice of the
+        // original bytes.
+        r := 0
+        for r < len(s) {
+                c := s[r]
+                if c == '\\' || c == '"' || c < ' ' {
+                        break
+                }
+                if c < utf8.RuneSelf {
+                        r++
+                        continue
+                }
+                rr, size := utf8.DecodeRune(s[r:])
+                if rr == utf8.RuneError {
+                        break
+                }
+                r += size
+        }
+        if r == len(s) {
+                return s, true
+        }
+
+        b := make([]byte, len(s)+2*utf8.UTFMax)
+        w := copy(b, s[0:r])
+        for r < len(s) {
+                // Out of room?  Can only happen if s is full of
+                // malformed UTF-8 and we're replacing each
+                // byte with RuneError.
+                if w >= len(b)-2*utf8.UTFMax {
+                        nb := make([]byte, (len(b)+utf8.UTFMax)*2)
+                        copy(nb, b[0:w])
+                        b = nb
+                }
+                switch c := s[r]; {
+                case c == '\\':
+                        r++
+                        if r >= len(s) {
+                                return
+                        }
+                        switch s[r] {
+                        default:
+                                return
+                        case '"', '\\', '/', '\'':
+                                b[w] = s[r]
+                                r++
+                                w++
+                        case 'b':
+                                b[w] = '\b'
+                                r++
+                                w++
+                        case 'f':
+                                b[w] = '\f'
+                                r++
+                                w++
+                        case 'n':
+                                b[w] = '\n'
+                                r++
+                                w++
+                        case 'r':
+                                b[w] = '\r'
+                                r++
+                                w++
+                        case 't':
+                                b[w] = '\t'
+                                r++
+                                w++
+                        case 'u':
+                                r--
+                                rr := getu4(s[r:])
+                                if rr < 0 {
+                                        return
+                                }
+                                r += 6
+                                if utf16.IsSurrogate(rr) {
+                                        rr1 := getu4(s[r:])
+                                        if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
+                                                // A valid pair; consume.
+                                                r += 6
+                                                w += utf8.EncodeRune(b[w:], dec)
+                                                break
+                                        }
+                                        // Invalid surrogate; fall back to replacement rune.
+                                        rr = unicode.ReplacementChar
+                                }
+                                w += utf8.EncodeRune(b[w:], rr)
+                        }
+
+                // Quote, control characters are invalid.
+                case c == '"', c < ' ':
+                        return
+
+                // ASCII
+                case c < utf8.RuneSelf:
+                        b[w] = c
+                        r++
+                        w++
+
+                // Coerce to well-formed UTF-8.
+                default:
+                        rr, size := utf8.DecodeRune(s[r:])
+                        r += size
+                        w += utf8.EncodeRune(b[w:], rr)
+                }
+        }
+        return b[0:w], true
+}
diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/README.md b/vendor/github.com/konsorten/go-windows-terminal-sequences/README.md
deleted file mode 100644
index 195333e..0000000
--- a/vendor/github.com/konsorten/go-windows-terminal-sequences/README.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Windows Terminal Sequences
-
-This library allow for enabling Windows terminal color support for Go.
-
-See [Console Virtual Terminal Sequences](https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences) for details.
-
-## Usage
-
-```go
-import (
-        "syscall"
-        
-        sequences "github.com/konsorten/go-windows-terminal-sequences"
-)
-
-func main() {
-        sequences.EnableVirtualTerminalProcessing(syscall.Stdout, true)
-}
-
-```
-
-## Authors
-
-The tool is sponsored by the [marvin + konsorten GmbH](http://www.konsorten.de).
-
-We thank all the authors who provided code to this library:
-
-* Felix Kollmann
-* Nicolas Perraut
-
-## License
-
-(The MIT License)
-
-Copyright (c) 2018 marvin + konsorten GmbH (open-source@konsorten.de)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 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.
diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/go.mod b/vendor/github.com/konsorten/go-windows-terminal-sequences/go.mod
deleted file mode 100644
index 716c613..0000000
--- a/vendor/github.com/konsorten/go-windows-terminal-sequences/go.mod
+++ /dev/null
@@ -1 +0,0 @@
-module github.com/konsorten/go-windows-terminal-sequences
diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences.go b/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences.go
deleted file mode 100644
index ef18d8f..0000000
--- a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// +build windows
-
-package sequences
-
-import (
-        "syscall"
-        "unsafe"
-)
-
-var (
-        kernel32Dll    *syscall.LazyDLL  = syscall.NewLazyDLL("Kernel32.dll")
-        setConsoleMode *syscall.LazyProc = kernel32Dll.NewProc("SetConsoleMode")
-)
-
-func EnableVirtualTerminalProcessing(stream syscall.Handle, enable bool) error {
-        const ENABLE_VIRTUAL_TERMINAL_PROCESSING uint32 = 0x4
-
-        var mode uint32
-        err := syscall.GetConsoleMode(syscall.Stdout, &mode)
-        if err != nil {
-                return err
-        }
-
-        if enable {
-                mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING
-        } else {
-                mode &^= ENABLE_VIRTUAL_TERMINAL_PROCESSING
-        }
-
-        ret, _, err := setConsoleMode.Call(uintptr(unsafe.Pointer(stream)), uintptr(mode))
-        if ret == 0 {
-                return err
-        }
-
-        return nil
-}
diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences_dummy.go b/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences_dummy.go
deleted file mode 100644
index df61a6f..0000000
--- a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences_dummy.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// +build linux darwin
-
-package sequences
-
-import (
-        "fmt"
-)
-
-func EnableVirtualTerminalProcessing(stream uintptr, enable bool) error {
-        return fmt.Errorf("windows only package")
-}
diff --git a/vendor/github.com/kr/logfmt/.gitignore b/vendor/github.com/kr/logfmt/.gitignore
new file mode 100644
index 0000000..8e524f6
--- /dev/null
+++ b/vendor/github.com/kr/logfmt/.gitignore
@@ -0,0 +1,3 @@
+*.test
+*.swp
+*.prof
diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/LICENSE b/vendor/github.com/kr/logfmt/Readme
index 14127cd..1865a11 100644
--- a/vendor/github.com/konsorten/go-windows-terminal-sequences/LICENSE
+++ b/vendor/github.com/kr/logfmt/Readme
@@ -1,9 +1,12 @@
-(The MIT License)
+Go package for parsing (and, eventually, generating)
+log lines in the logfmt style.
 
-Copyright (c) 2017 marvin + konsorten GmbH (open-source@konsorten.de)
+See http://godoc.org/github.com/kr/logfmt for format, and other documentation and examples.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Copyright (C) 2013 Keith Rarick, Blake Mizerany
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 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.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 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.
diff --git a/vendor/github.com/kr/logfmt/decode.go b/vendor/github.com/kr/logfmt/decode.go
new file mode 100644
index 0000000..1397fb7
--- /dev/null
+++ b/vendor/github.com/kr/logfmt/decode.go
@@ -0,0 +1,184 @@
+// Package implements the decoding of logfmt key-value pairs.
+//
+// Example logfmt message:
+//
+//      foo=bar a=14 baz="hello kitty" cool%story=bro f %^asdf
+//
+// Example result in JSON:
+//
+//      { "foo": "bar", "a": 14, "baz": "hello kitty", "cool%story": "bro", "f": true, "%^asdf": true }
+//
+// EBNFish:
+//
+//      ident_byte = any byte greater than ' ', excluding '=' and '"'
+//      string_byte = any byte excluding '"' and '\'
+//      garbage = !ident_byte
+//      ident = ident_byte, { ident byte }
+//      key = ident
+//      value = ident | '"', { string_byte | '\', '"' }, '"'
+//      pair = key, '=', value | key, '=' | key
+//      message = { garbage, pair }, garbage
+package logfmt
+
+import (
+        "reflect"
+        "strconv"
+        "strings"
+        "time"
+)
+
+// Handler is the interface implemented by objects that accept logfmt
+// key-value pairs. HandleLogfmt must copy the logfmt data if it
+// wishes to retain the data after returning.
+type Handler interface {
+        HandleLogfmt(key, val []byte) error
+}
+
+// The HandlerFunc type is an adapter to allow the use of ordinary functions as
+// logfmt handlers. If f is a function with the appropriate signature,
+// HandlerFunc(f) is a Handler object that calls f.
+type HandlerFunc func(key, val []byte) error
+
+func (f HandlerFunc) HandleLogfmt(key, val []byte) error {
+        return f(key, val)
+}
+
+// Unmarshal parses the logfmt encoding data and stores the result in the value
+// pointed to by v. If v is an Handler, HandleLogfmt will be called for each
+// key-value pair.
+//
+// If v is not a Handler, it will pass v to NewStructHandler and use the
+// returned StructHandler for decoding.
+func Unmarshal(data []byte, v interface{}) (err error) {
+        h, ok := v.(Handler)
+        if !ok {
+                h, err = NewStructHandler(v)
+                if err != nil {
+                        return err
+                }
+        }
+        return gotoScanner(data, h)
+}
+
+// StructHandler unmarshals logfmt into a struct. It matches incoming keys to
+// the the struct's fields (either the struct field name or its tag, preferring
+// an exact match but also accepting a case-insensitive match.
+//
+// Field types supported by StructHandler are:
+//
+//      all numeric types (e.g. float32, int, etc.)
+//      []byte
+//      string
+//      bool - true if key is present, false otherwise (the value is ignored).
+//      time.Duration - uses time.ParseDuration
+//
+// If a field is a pointer to an above type, and a matching key is not present
+// in the logfmt data, the pointer will be untouched.
+//
+// If v is not a pointer to an Handler or struct, Unmarshal will return an
+// error.
+type StructHandler struct {
+        rv reflect.Value
+}
+
+func NewStructHandler(v interface{}) (Handler, error) {
+        rv := reflect.ValueOf(v)
+        if rv.Kind() != reflect.Ptr || rv.IsNil() {
+                return nil, &InvalidUnmarshalError{reflect.TypeOf(v)}
+        }
+        return &StructHandler{rv: rv}, nil
+}
+
+func (h *StructHandler) HandleLogfmt(key, val []byte) error {
+        el := h.rv.Elem()
+        skey := string(key)
+        for i := 0; i < el.NumField(); i++ {
+                fv := el.Field(i)
+                ft := el.Type().Field(i)
+                switch {
+                case ft.Name == skey:
+                case ft.Tag.Get("logfmt") == skey:
+                case strings.EqualFold(ft.Name, skey):
+                default:
+                        continue
+                }
+                if fv.Kind() == reflect.Ptr {
+                        if fv.IsNil() {
+                                t := fv.Type().Elem()
+                                v := reflect.New(t)
+                                fv.Set(v)
+                                fv = v
+                        }
+                        fv = fv.Elem()
+                }
+                switch fv.Interface().(type) {
+                case time.Duration:
+                        d, err := time.ParseDuration(string(val))
+                        if err != nil {
+                                return &UnmarshalTypeError{string(val), fv.Type()}
+                        }
+                        fv.Set(reflect.ValueOf(d))
+                case string:
+                        fv.SetString(string(val))
+                case []byte:
+                        b := make([]byte, len(val))
+                        copy(b, val)
+                        fv.SetBytes(b)
+                case bool:
+                        fv.SetBool(true)
+                default:
+                        switch {
+                        case reflect.Int <= fv.Kind() && fv.Kind() <= reflect.Int64:
+                                v, err := strconv.ParseInt(string(val), 10, 64)
+                                if err != nil {
+                                        return err
+                                }
+                                fv.SetInt(v)
+                        case reflect.Uint32 <= fv.Kind() && fv.Kind() <= reflect.Uint64:
+                                v, err := strconv.ParseUint(string(val), 10, 64)
+                                if err != nil {
+                                        return err
+                                }
+                                fv.SetUint(v)
+                        case reflect.Float32 <= fv.Kind() && fv.Kind() <= reflect.Float64:
+                                v, err := strconv.ParseFloat(string(val), 10)
+                                if err != nil {
+                                        return err
+                                }
+                                fv.SetFloat(v)
+                        default:
+                                return &UnmarshalTypeError{string(val), fv.Type()}
+                        }
+                }
+
+        }
+        return nil
+}
+
+// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+// (The argument to Unmarshal must be a non-nil pointer.)
+type InvalidUnmarshalError struct {
+        Type reflect.Type
+}
+
+func (e *InvalidUnmarshalError) Error() string {
+        if e.Type == nil {
+                return "logfmt: Unmarshal(nil)"
+        }
+
+        if e.Type.Kind() != reflect.Ptr {
+                return "logfmt: Unmarshal(non-pointer " + e.Type.String() + ")"
+        }
+        return "logfmt: Unmarshal(nil " + e.Type.String() + ")"
+}
+
+// An UnmarshalTypeError describes a logfmt value that was
+// not appropriate for a value of a specific Go type.
+type UnmarshalTypeError struct {
+        Value string       // the logfmt value
+        Type  reflect.Type // type of Go value it could not be assigned to
+}
+
+func (e *UnmarshalTypeError) Error() string {
+        return "logfmt: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
+}
diff --git a/vendor/github.com/kr/logfmt/scanner.go b/vendor/github.com/kr/logfmt/scanner.go
new file mode 100644
index 0000000..095221f
--- /dev/null
+++ b/vendor/github.com/kr/logfmt/scanner.go
@@ -0,0 +1,149 @@
+package logfmt
+
+import (
+        "errors"
+        "fmt"
+)
+
+var ErrUnterminatedString = errors.New("logfmt: unterminated string")
+
+func gotoScanner(data []byte, h Handler) (err error) {
+        saveError := func(e error) {
+                if err == nil {
+                        err = e
+                }
+        }
+
+        var c byte
+        var i int
+        var m int
+        var key []byte
+        var val []byte
+        var ok bool
+        var esc bool
+
+garbage:
+        if i == len(data) {
+                return
+        }
+
+        c = data[i]
+        switch {
+        case c > ' ' && c != '"' && c != '=':
+                key, val = nil, nil
+                m = i
+                i++
+                goto key
+        default:
+                i++
+                goto garbage
+        }
+
+key:
+        if i >= len(data) {
+                if m >= 0 {
+                        key = data[m:i]
+                        saveError(h.HandleLogfmt(key, nil))
+                }
+                return
+        }
+
+        c = data[i]
+        switch {
+        case c > ' ' && c != '"' && c != '=':
+                i++
+                goto key
+        case c == '=':
+                key = data[m:i]
+                i++
+                goto equal
+        default:
+                key = data[m:i]
+                i++
+                saveError(h.HandleLogfmt(key, nil))
+                goto garbage
+        }
+
+equal:
+        if i >= len(data) {
+                if m >= 0 {
+                        i--
+                        key = data[m:i]
+                        saveError(h.HandleLogfmt(key, nil))
+                }
+                return
+        }
+
+        c = data[i]
+        switch {
+        case c > ' ' && c != '"' && c != '=':
+                m = i
+                i++
+                goto ivalue
+        case c == '"':
+                m = i
+                i++
+                esc = false
+                goto qvalue
+        default:
+                if key != nil {
+                        saveError(h.HandleLogfmt(key, val))
+                }
+                i++
+                goto garbage
+        }
+
+ivalue:
+        if i >= len(data) {
+                if m >= 0 {
+                        val = data[m:i]
+                        saveError(h.HandleLogfmt(key, val))
+                }
+                return
+        }
+
+        c = data[i]
+        switch {
+        case c > ' ' && c != '"' && c != '=':
+                i++
+                goto ivalue
+        default:
+                val = data[m:i]
+                saveError(h.HandleLogfmt(key, val))
+                i++
+                goto garbage
+        }
+
+qvalue:
+        if i >= len(data) {
+                if m >= 0 {
+                        saveError(ErrUnterminatedString)
+                }
+                return
+        }
+
+        c = data[i]
+        switch c {
+        case '\\':
+                i += 2
+                esc = true
+                goto qvalue
+        case '"':
+                i++
+                val = data[m:i]
+                if esc {
+                        val, ok = unquoteBytes(val)
+                        if !ok {
+                                saveError(fmt.Errorf("logfmt: error unquoting bytes %q", string(val)))
+                                goto garbage
+                        }
+                } else {
+                        val = val[1 : len(val)-1]
+                }
+                saveError(h.HandleLogfmt(key, val))
+                goto garbage
+        default:
+                i++
+                goto qvalue
+        }
+}
diff --git a/vendor/github.com/kr/logfmt/unquote.go b/vendor/github.com/kr/logfmt/unquote.go
new file mode 100644
index 0000000..fb088a4
--- /dev/null
+++ b/vendor/github.com/kr/logfmt/unquote.go
@@ -0,0 +1,149 @@
+package logfmt
+
+import (
+        "strconv"
+        "unicode"
+        "unicode/utf16"
+        "unicode/utf8"
+)
+
+// Taken from Go's encoding/json
+
+// Copyright 2010 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.
+
+// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
+// or it returns -1.
+func getu4(s []byte) rune {
+        if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
+                return -1
+        }
+        r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
+        if err != nil {
+                return -1
+        }
+        return rune(r)
+}
+
+// unquote converts a quoted JSON string literal s into an actual string t.
+// The rules are different than for Go, so cannot use strconv.Unquote.
+func unquote(s []byte) (t string, ok bool) {
+        s, ok = unquoteBytes(s)
+        t = string(s)
+        return
+}
+
+func unquoteBytes(s []byte) (t []byte, ok bool) {
+        if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
+                return
+        }
+        s = s[1 : len(s)-1]
+
+        // Check for unusual characters. If there are none,
+        // then no unquoting is needed, so return a slice of the
+        // original bytes.
+        r := 0
+        for r < len(s) {
+                c := s[r]
+                if c == '\\' || c == '"' || c < ' ' {
+                        break
+                }
+                if c < utf8.RuneSelf {
+                        r++
+                        continue
+                }
+                rr, size := utf8.DecodeRune(s[r:])
+                if rr == utf8.RuneError && size == 1 {
+                        break
+                }
+                r += size
+        }
+        if r == len(s) {
+                return s, true
+        }
+
+        b := make([]byte, len(s)+2*utf8.UTFMax)
+        w := copy(b, s[0:r])
+        for r < len(s) {
+                // Out of room?  Can only happen if s is full of
+                // malformed UTF-8 and we're replacing each
+                // byte with RuneError.
+                if w >= len(b)-2*utf8.UTFMax {
+                        nb := make([]byte, (len(b)+utf8.UTFMax)*2)
+                        copy(nb, b[0:w])
+                        b = nb
+                }
+                switch c := s[r]; {
+                case c == '\\':
+                        r++
+                        if r >= len(s) {
+                                return
+                        }
+                        switch s[r] {
+                        default:
+                                return
+                        case '"', '\\', '/', '\'':
+                                b[w] = s[r]
+                                r++
+                                w++
+                        case 'b':
+                                b[w] = '\b'
+                                r++
+                                w++
+                        case 'f':
+                                b[w] = '\f'
+                                r++
+                                w++
+                        case 'n':
+                                b[w] = '\n'
+                                r++
+                                w++
+                        case 'r':
+                                b[w] = '\r'
+                                r++
+                                w++
+                        case 't':
+                                b[w] = '\t'
+                                r++
+                                w++
+                        case 'u':
+                                r--
+                                rr := getu4(s[r:])
+                                if rr < 0 {
+                                        return
+                                }
+                                r += 6
+                                if utf16.IsSurrogate(rr) {
+                                        rr1 := getu4(s[r:])
+                                        if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
+                                                // A valid pair; consume.
+                                                r += 6
+                                                w += utf8.EncodeRune(b[w:], dec)
+                                                break
+                                        }
+                                        // Invalid surrogate; fall back to replacement rune.
+                                        rr = unicode.ReplacementChar
+                                }
+                                w += utf8.EncodeRune(b[w:], rr)
+                        }
+
+                // Quote, control characters are invalid.
+                case c == '"', c < ' ':
+                        return
+
+                // ASCII
+                case c < utf8.RuneSelf:
+                        b[w] = c
+                        r++
+                        w++
+
+                // Coerce to well-formed UTF-8.
+                default:
+                        rr, size := utf8.DecodeRune(s[r:])
+                        r += size
+                        w += utf8.EncodeRune(b[w:], rr)
+                }
+        }
+        return b[0:w], true
+}
diff --git a/vendor/github.com/prometheus/common/log/eventlog_formatter.go b/vendor/github.com/prometheus/common/log/eventlog_formatter.go
deleted file mode 100644
index bcf68e6..0000000
--- a/vendor/github.com/prometheus/common/log/eventlog_formatter.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2015 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// +build windows
-
-package log
-
-import (
-        "fmt"
-        "os"
-
-        "golang.org/x/sys/windows/svc/eventlog"
-
-        "github.com/sirupsen/logrus"
-)
-
-func init() {
-        setEventlogFormatter = func(l logger, name string, debugAsInfo bool) error {
-                if name == "" {
-                        return fmt.Errorf("missing name parameter")
-                }
-
-                fmter, err := newEventlogger(name, debugAsInfo, l.entry.Logger.Formatter)
-                if err != nil {
-                        fmt.Fprintf(os.Stderr, "error creating eventlog formatter: %v\n", err)
-                        l.Errorf("can't connect logger to eventlog: %v", err)
-                        return err
-                }
-                l.entry.Logger.Formatter = fmter
-                return nil
-        }
-}
-
-type eventlogger struct {
-        log         *eventlog.Log
-        debugAsInfo bool
-        wrap        logrus.Formatter
-}
-
-func newEventlogger(name string, debugAsInfo bool, fmter logrus.Formatter) (*eventlogger, error) {
-        logHandle, err := eventlog.Open(name)
-        if err != nil {
-                return nil, err
-        }
-        return &eventlogger{log: logHandle, debugAsInfo: debugAsInfo, wrap: fmter}, nil
-}
-
-func (s *eventlogger) Format(e *logrus.Entry) ([]byte, error) {
-        data, err := s.wrap.Format(e)
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "eventlogger: can't format entry: %v\n", err)
-                return data, err
-        }
-
-        switch e.Level {
-        case logrus.PanicLevel:
-                fallthrough
-        case logrus.FatalLevel:
-                fallthrough
-        case logrus.ErrorLevel:
-                err = s.log.Error(102, e.Message)
-        case logrus.WarnLevel:
-                err = s.log.Warning(101, e.Message)
-        case logrus.InfoLevel:
-                err = s.log.Info(100, e.Message)
-        case logrus.DebugLevel:
-                if s.debugAsInfo {
-                        err = s.log.Info(100, e.Message)
-                }
-        default:
-                err = s.log.Info(100, e.Message)
-        }
-
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "eventlogger: can't send log to eventlog: %v\n", err)
-        }
-
-        return data, err
-}
diff --git a/vendor/github.com/prometheus/common/log/log.go b/vendor/github.com/prometheus/common/log/log.go
deleted file mode 100644
index 1088302..0000000
--- a/vendor/github.com/prometheus/common/log/log.go
+++ /dev/null
@@ -1,364 +0,0 @@
-// Copyright 2015 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package log
-
-import (
-        "fmt"
-        "io"
-        "io/ioutil"
-        "log"
-        "net/url"
-        "os"
-        "runtime"
-        "strconv"
-        "strings"
-
-        "github.com/sirupsen/logrus"
-        "gopkg.in/alecthomas/kingpin.v2"
-)
-
-// setSyslogFormatter is nil if the target architecture does not support syslog.
-var setSyslogFormatter func(logger, string, string) error
-
-// setEventlogFormatter is nil if the target OS does not support Eventlog (i.e., is not Windows).
-var setEventlogFormatter func(logger, string, bool) error
-
-func setJSONFormatter() {
-        origLogger.Formatter = &logrus.JSONFormatter{}
-}
-
-type loggerSettings struct {
-        level  string
-        format string
-}
-
-func (s *loggerSettings) apply(ctx *kingpin.ParseContext) error {
-        err := baseLogger.SetLevel(s.level)
-        if err != nil {
-                return err
-        }
-        err = baseLogger.SetFormat(s.format)
-        return err
-}
-
-// AddFlags adds the flags used by this package to the Kingpin application.
-// To use the default Kingpin application, call AddFlags(kingpin.CommandLine)
-func AddFlags(a *kingpin.Application) {
-        s := loggerSettings{}
-        a.Flag("log.level", "Only log messages with the given severity or above. Valid levels: [debug, info, warn, error, fatal]").
-                Default(origLogger.Level.String()).
-                StringVar(&s.level)
-        defaultFormat := url.URL{Scheme: "logger", Opaque: "stderr"}
-        a.Flag("log.format", `Set the log target and format. Example: "logger:syslog?appname=bob&local=7" or "logger:stdout?json=true"`).
-                Default(defaultFormat.String()).
-                StringVar(&s.format)
-        a.Action(s.apply)
-}
-
-// Logger is the interface for loggers used in the Prometheus components.
-type Logger interface {
-        Debug(...interface{})
-        Debugln(...interface{})
-        Debugf(string, ...interface{})
-
-        Info(...interface{})
-        Infoln(...interface{})
-        Infof(string, ...interface{})
-
-        Warn(...interface{})
-        Warnln(...interface{})
-        Warnf(string, ...interface{})
-
-        Error(...interface{})
-        Errorln(...interface{})
-        Errorf(string, ...interface{})
-
-        Fatal(...interface{})
-        Fatalln(...interface{})
-        Fatalf(string, ...interface{})
-
-        With(key string, value interface{}) Logger
-
-        SetFormat(string) error
-        SetLevel(string) error
-}
-
-type logger struct {
-        entry *logrus.Entry
-}
-
-func (l logger) With(key string, value interface{}) Logger {
-        return logger{l.entry.WithField(key, value)}
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func (l logger) Debug(args ...interface{}) {
-        l.sourced().Debug(args...)
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func (l logger) Debugln(args ...interface{}) {
-        l.sourced().Debugln(args...)
-}
-
-// Debugf logs a message at level Debug on the standard logger.
-func (l logger) Debugf(format string, args ...interface{}) {
-        l.sourced().Debugf(format, args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func (l logger) Info(args ...interface{}) {
-        l.sourced().Info(args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func (l logger) Infoln(args ...interface{}) {
-        l.sourced().Infoln(args...)
-}
-
-// Infof logs a message at level Info on the standard logger.
-func (l logger) Infof(format string, args ...interface{}) {
-        l.sourced().Infof(format, args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func (l logger) Warn(args ...interface{}) {
-        l.sourced().Warn(args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func (l logger) Warnln(args ...interface{}) {
-        l.sourced().Warnln(args...)
-}
-
-// Warnf logs a message at level Warn on the standard logger.
-func (l logger) Warnf(format string, args ...interface{}) {
-        l.sourced().Warnf(format, args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func (l logger) Error(args ...interface{}) {
-        l.sourced().Error(args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func (l logger) Errorln(args ...interface{}) {
-        l.sourced().Errorln(args...)
-}
-
-// Errorf logs a message at level Error on the standard logger.
-func (l logger) Errorf(format string, args ...interface{}) {
-        l.sourced().Errorf(format, args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger.
-func (l logger) Fatal(args ...interface{}) {
-        l.sourced().Fatal(args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger.
-func (l logger) Fatalln(args ...interface{}) {
-        l.sourced().Fatalln(args...)
-}
-
-// Fatalf logs a message at level Fatal on the standard logger.
-func (l logger) Fatalf(format string, args ...interface{}) {
-        l.sourced().Fatalf(format, args...)
-}
-
-func (l logger) SetLevel(level string) error {
-        lvl, err := logrus.ParseLevel(level)
-        if err != nil {
-                return err
-        }
-
-        l.entry.Logger.Level = lvl
-        return nil
-}
-
-func (l logger) SetFormat(format string) error {
-        u, err := url.Parse(format)
-        if err != nil {
-                return err
-        }
-        if u.Scheme != "logger" {
-                return fmt.Errorf("invalid scheme %s", u.Scheme)
-        }
-        jsonq := u.Query().Get("json")
-        if jsonq == "true" {
-                setJSONFormatter()
-        }
-
-        switch u.Opaque {
-        case "syslog":
-                if setSyslogFormatter == nil {
-                        return fmt.Errorf("system does not support syslog")
-                }
-                appname := u.Query().Get("appname")
-                facility := u.Query().Get("local")
-                return setSyslogFormatter(l, appname, facility)
-        case "eventlog":
-                if setEventlogFormatter == nil {
-                        return fmt.Errorf("system does not support eventlog")
-                }
-                name := u.Query().Get("name")
-                debugAsInfo := false
-                debugAsInfoRaw := u.Query().Get("debugAsInfo")
-                if parsedDebugAsInfo, err := strconv.ParseBool(debugAsInfoRaw); err == nil {
-                        debugAsInfo = parsedDebugAsInfo
-                }
-                return setEventlogFormatter(l, name, debugAsInfo)
-        case "stdout":
-                l.entry.Logger.Out = os.Stdout
-        case "stderr":
-                l.entry.Logger.Out = os.Stderr
-        default:
-                return fmt.Errorf("unsupported logger %q", u.Opaque)
-        }
-        return nil
-}
-
-// sourced adds a source field to the logger that contains
-// the file name and line where the logging happened.
-func (l logger) sourced() *logrus.Entry {
-        _, file, line, ok := runtime.Caller(2)
-        if !ok {
-                file = "<???>"
-                line = 1
-        } else {
-                slash := strings.LastIndex(file, "/")
-                file = file[slash+1:]
-        }
-        return l.entry.WithField("source", fmt.Sprintf("%s:%d", file, line))
-}
-
-var origLogger = logrus.New()
-var baseLogger = logger{entry: logrus.NewEntry(origLogger)}
-
-// Base returns the default Logger logging to
-func Base() Logger {
-        return baseLogger
-}
-
-// NewLogger returns a new Logger logging to out.
-func NewLogger(w io.Writer) Logger {
-        l := logrus.New()
-        l.Out = w
-        return logger{entry: logrus.NewEntry(l)}
-}
-
-// NewNopLogger returns a logger that discards all log messages.
-func NewNopLogger() Logger {
-        l := logrus.New()
-        l.Out = ioutil.Discard
-        return logger{entry: logrus.NewEntry(l)}
-}
-
-// With adds a field to the logger.
-func With(key string, value interface{}) Logger {
-        return baseLogger.With(key, value)
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func Debug(args ...interface{}) {
-        baseLogger.sourced().Debug(args...)
-}
-
-// Debugln logs a message at level Debug on the standard logger.
-func Debugln(args ...interface{}) {
-        baseLogger.sourced().Debugln(args...)
-}
-
-// Debugf logs a message at level Debug on the standard logger.
-func Debugf(format string, args ...interface{}) {
-        baseLogger.sourced().Debugf(format, args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func Info(args ...interface{}) {
-        baseLogger.sourced().Info(args...)
-}
-
-// Infoln logs a message at level Info on the standard logger.
-func Infoln(args ...interface{}) {
-        baseLogger.sourced().Infoln(args...)
-}
-
-// Infof logs a message at level Info on the standard logger.
-func Infof(format string, args ...interface{}) {
-        baseLogger.sourced().Infof(format, args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func Warn(args ...interface{}) {
-        baseLogger.sourced().Warn(args...)
-}
-
-// Warnln logs a message at level Warn on the standard logger.
-func Warnln(args ...interface{}) {
-        baseLogger.sourced().Warnln(args...)
-}
-
-// Warnf logs a message at level Warn on the standard logger.
-func Warnf(format string, args ...interface{}) {
-        baseLogger.sourced().Warnf(format, args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func Error(args ...interface{}) {
-        baseLogger.sourced().Error(args...)
-}
-
-// Errorln logs a message at level Error on the standard logger.
-func Errorln(args ...interface{}) {
-        baseLogger.sourced().Errorln(args...)
-}
-
-// Errorf logs a message at level Error on the standard logger.
-func Errorf(format string, args ...interface{}) {
-        baseLogger.sourced().Errorf(format, args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger.
-func Fatal(args ...interface{}) {
-        baseLogger.sourced().Fatal(args...)
-}
-
-// Fatalln logs a message at level Fatal on the standard logger.
-func Fatalln(args ...interface{}) {
-        baseLogger.sourced().Fatalln(args...)
-}
-
-// Fatalf logs a message at level Fatal on the standard logger.
-func Fatalf(format string, args ...interface{}) {
-        baseLogger.sourced().Fatalf(format, args...)
-}
-
-// AddHook adds hook to Prometheus' original logger.
-func AddHook(hook logrus.Hook) {
-        origLogger.Hooks.Add(hook)
-}
-
-type errorLogWriter struct{}
-
-func (errorLogWriter) Write(b []byte) (int, error) {
-        baseLogger.sourced().Error(string(b))
-        return len(b), nil
-}
-
-// NewErrorLogger returns a log.Logger that is meant to be used
-// in the ErrorLog field of an http.Server to log HTTP server errors.
-func NewErrorLogger() *log.Logger {
-        return log.New(&errorLogWriter{}, "", 0)
-}
diff --git a/vendor/github.com/prometheus/common/log/syslog_formatter.go b/vendor/github.com/prometheus/common/log/syslog_formatter.go
deleted file mode 100644
index f882f2f..0000000
--- a/vendor/github.com/prometheus/common/log/syslog_formatter.go
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright 2015 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// +build !windows,!nacl,!plan9
-
-package log
-
-import (
-        "fmt"
-        "log/syslog"
-        "os"
-
-        "github.com/sirupsen/logrus"
-)
-
-var _ logrus.Formatter = (*syslogger)(nil)
-
-func init() {
-        setSyslogFormatter = func(l logger, appname, local string) error {
-                if appname == "" {
-                        return fmt.Errorf("missing appname parameter")
-                }
-                if local == "" {
-                        return fmt.Errorf("missing local parameter")
-                }
-
-                fmter, err := newSyslogger(appname, local, l.entry.Logger.Formatter)
-                if err != nil {
-                        fmt.Fprintf(os.Stderr, "error creating syslog formatter: %v\n", err)
-                        l.entry.Errorf("can't connect logger to syslog: %v", err)
-                        return err
-                }
-                l.entry.Logger.Formatter = fmter
-                return nil
-        }
-}
-
-var prefixTag []byte
-
-type syslogger struct {
-        wrap logrus.Formatter
-        out  *syslog.Writer
-}
-
-func newSyslogger(appname string, facility string, fmter logrus.Formatter) (*syslogger, error) {
-        priority, err := getFacility(facility)
-        if err != nil {
-                return nil, err
-        }
-        out, err := syslog.New(priority, appname)
-        _, isJSON := fmter.(*logrus.JSONFormatter)
-        if isJSON {
-                // add cee tag to json formatted syslogs
-                prefixTag = []byte("@cee:")
-        }
-        return &syslogger{
-                out:  out,
-                wrap: fmter,
-        }, err
-}
-
-func getFacility(facility string) (syslog.Priority, error) {
-        switch facility {
-        case "0":
-                return syslog.LOG_LOCAL0, nil
-        case "1":
-                return syslog.LOG_LOCAL1, nil
-        case "2":
-                return syslog.LOG_LOCAL2, nil
-        case "3":
-                return syslog.LOG_LOCAL3, nil
-        case "4":
-                return syslog.LOG_LOCAL4, nil
-        case "5":
-                return syslog.LOG_LOCAL5, nil
-        case "6":
-                return syslog.LOG_LOCAL6, nil
-        case "7":
-                return syslog.LOG_LOCAL7, nil
-        }
-        return syslog.LOG_LOCAL0, fmt.Errorf("invalid local(%s) for syslog", facility)
-}
-
-func (s *syslogger) Format(e *logrus.Entry) ([]byte, error) {
-        data, err := s.wrap.Format(e)
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "syslogger: can't format entry: %v\n", err)
-                return data, err
-        }
-        // only append tag to data sent to syslog (line), not to what
-        // is returned
-        line := string(append(prefixTag, data...))
-
-        switch e.Level {
-        case logrus.PanicLevel:
-                err = s.out.Crit(line)
-        case logrus.FatalLevel:
-                err = s.out.Crit(line)
-        case logrus.ErrorLevel:
-                err = s.out.Err(line)
-        case logrus.WarnLevel:
-                err = s.out.Warning(line)
-        case logrus.InfoLevel:
-                err = s.out.Info(line)
-        case logrus.DebugLevel:
-                err = s.out.Debug(line)
-        default:
-                err = s.out.Notice(line)
-        }
-
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "syslogger: can't send log to syslog: %v\n", err)
-        }
-
-        return data, err
-}
diff --git a/vendor/github.com/prometheus/common/promlog/flag/flag.go b/vendor/github.com/prometheus/common/promlog/flag/flag.go
new file mode 100644
index 0000000..ec55008
--- /dev/null
+++ b/vendor/github.com/prometheus/common/promlog/flag/flag.go
@@ -0,0 +1,45 @@
+// Copyright 2017 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package flag
+
+import (
+        "github.com/prometheus/common/promlog"
+        kingpin "gopkg.in/alecthomas/kingpin.v2"
+)
+
+// LevelFlagName is the canonical flag name to configure the allowed log level
+// within Prometheus projects.
+const LevelFlagName = "log.level"
+
+// LevelFlagHelp is the help description for the log.level flag.
+const LevelFlagHelp = "Only log messages with the given severity or above. One of: [debug, info, warn, error]"
+
+// FormatFlagName is the canonical flag name to configure the log format
+// within Prometheus projects.
+const FormatFlagName = "log.format"
+
+// FormatFlagHelp is the help description for the log.format flag.
+const FormatFlagHelp = "Output format of log messages. One of: [logfmt, json]"
+
+// AddFlags adds the flags used by this package to the Kingpin application.
+// To use the default Kingpin application, call AddFlags(kingpin.CommandLine)
+func AddFlags(a *kingpin.Application, config *promlog.Config) {
+        config.Level = &promlog.AllowedLevel{}
+        a.Flag(LevelFlagName, LevelFlagHelp).
+                Default("info").SetValue(config.Level)
+
+        config.Format = &promlog.AllowedFormat{}
+        a.Flag(FormatFlagName, FormatFlagHelp).
+                Default("logfmt").SetValue(config.Format)
+}
diff --git a/vendor/github.com/prometheus/common/promlog/log.go b/vendor/github.com/prometheus/common/promlog/log.go
new file mode 100644
index 0000000..45fcbc4
--- /dev/null
+++ b/vendor/github.com/prometheus/common/promlog/log.go
@@ -0,0 +1,106 @@
+// Copyright 2017 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package promlog defines standardised ways to initialize Go kit loggers
+// across Prometheus components.
+// It should typically only ever be imported by main packages.
+package promlog
+
+import (
+        "os"
+        "time"
+
+        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
+        "github.com/pkg/errors"
+)
+
+var (
+        // This timestamp format differs from RFC3339Nano by using .000 instead
+        // of .999999999 which changes the timestamp from 9 variable to 3 fixed
+        // decimals (.130 instead of .130987456).
+        timestampFormat = log.TimestampFormat(
+                func() time.Time { return time.Now().UTC() },
+                "2006-01-02T15:04:05.000Z07:00",
+        )
+)
+
+// AllowedLevel is a settable identifier for the minimum level a log entry
+// must be have.
+type AllowedLevel struct {
+        s string
+        o level.Option
+}
+
+func (l *AllowedLevel) String() string {
+        return l.s
+}
+
+// Set updates the value of the allowed level.
+func (l *AllowedLevel) Set(s string) error {
+        switch s {
+        case "debug":
+                l.o = level.AllowDebug()
+        case "info":
+                l.o = level.AllowInfo()
+        case "warn":
+                l.o = level.AllowWarn()
+        case "error":
+                l.o = level.AllowError()
+        default:
+                return errors.Errorf("unrecognized log level %q", s)
+        }
+        l.s = s
+        return nil
+}
+
+// AllowedFormat is a settable identifier for the output format that the logger can have.
+type AllowedFormat struct {
+        s string
+}
+
+func (f *AllowedFormat) String() string {
+        return f.s
+}
+
+// Set updates the value of the allowed format.
+func (f *AllowedFormat) Set(s string) error {
+        switch s {
+        case "logfmt", "json":
+                f.s = s
+        default:
+                return errors.Errorf("unrecognized log format %q", s)
+        }
+        return nil
+}
+
+// Config is a struct containing configurable settings for the logger
+type Config struct {
+        Level  *AllowedLevel
+        Format *AllowedFormat
+}
+
+// New returns a new leveled oklog logger. Each logged line will be annotated
+// with a timestamp. The output always goes to stderr.
+func New(config *Config) log.Logger {
+        var l log.Logger
+        if config.Format.s == "logfmt" {
+                l = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
+        } else {
+                l = log.NewJSONLogger(log.NewSyncWriter(os.Stderr))
+        }
+
+        l = level.NewFilter(l, config.Level.o)
+        l = log.With(l, "ts", timestampFormat, "caller", log.DefaultCaller)
+        return l
+}
diff --git a/vendor/github.com/sirupsen/logrus/.gitignore b/vendor/github.com/sirupsen/logrus/.gitignore
deleted file mode 100644
index 6b7d7d1..0000000
--- a/vendor/github.com/sirupsen/logrus/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-logrus
-vendor
diff --git a/vendor/github.com/sirupsen/logrus/.travis.yml b/vendor/github.com/sirupsen/logrus/.travis.yml
deleted file mode 100644
index 848938a..0000000
--- a/vendor/github.com/sirupsen/logrus/.travis.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-language: go
-go_import_path: github.com/sirupsen/logrus
-git:
-  depth: 1
-env:
-  - GO111MODULE=on
-  - GO111MODULE=off
-go: [ 1.11.x, 1.12.x ]
-os: [ linux, osx ]
-matrix:
-  exclude:
-    - go: 1.12.x
-      env: GO111MODULE=off
-    - go: 1.11.x
-      os: osx
-install:
-  - ./travis/install.sh
-  - if [[ "$GO111MODULE" ==  "on" ]]; then go mod download; fi
-  - if [[ "$GO111MODULE" == "off" ]]; then go get github.com/stretchr/testify/assert golang.org/x/sys/unix github.com/konsorten/go-windows-terminal-sequences; fi
-script:
-  - ./travis/cross_build.sh
-  - export GOMAXPROCS=4
-  - export GORACE=halt_on_error=1
-  - go test -race -v ./...
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then go test -race -v -tags appengine ./... ; fi
diff --git a/vendor/github.com/sirupsen/logrus/CHANGELOG.md b/vendor/github.com/sirupsen/logrus/CHANGELOG.md
deleted file mode 100644
index 51a7ab0..0000000
--- a/vendor/github.com/sirupsen/logrus/CHANGELOG.md
+++ /dev/null
@@ -1,200 +0,0 @@
-# 1.4.2
-  * Fixes build break for plan9, nacl, solaris
-# 1.4.1
-This new release introduces:
-  * Enhance TextFormatter to not print caller information when they are empty (#944)
-  * Remove dependency on golang.org/x/crypto (#932, #943) 
-
-Fixes:
-  * Fix Entry.WithContext method to return a copy of the initial entry (#941)
-
-# 1.4.0
-This new release introduces:
-  * Add `DeferExitHandler`, similar to `RegisterExitHandler` but prepending the handler to the list of handlers (semantically like `defer`) (#848).
-  * Add `CallerPrettyfier` to `JSONFormatter` and `TextFormatter (#909, #911)
-  * Add `Entry.WithContext()` and `Entry.Context`, to set a context on entries to be used e.g. in hooks (#919).
-
-Fixes:
-  * Fix wrong method calls `Logger.Print` and `Logger.Warningln` (#893).
-  * Update `Entry.Logf` to not do string formatting unless the log level is enabled (#903)
-  * Fix infinite recursion on unknown `Level.String()` (#907)
-  * Fix race condition in `getCaller` (#916).
-
-
-# 1.3.0
-This new release introduces:
-  * Log, Logf, Logln functions for Logger and Entry that take a Level
-
-Fixes:
-  * Building prometheus node_exporter on AIX (#840)
-  * Race condition in TextFormatter (#468)
-  * Travis CI import path (#868)
-  * Remove coloured output on Windows (#862)
-  * Pointer to func as field in JSONFormatter (#870)
-  * Properly marshal Levels (#873)
-
-# 1.2.0
-This new release introduces:
-  * A new method `SetReportCaller` in the `Logger` to enable the file, line and calling function from which the trace has been issued
-  * A new trace level named `Trace` whose level is below `Debug`
-  * A configurable exit function to be called upon a Fatal trace
-  * The `Level` object now implements `encoding.TextUnmarshaler` interface
-
-# 1.1.1
-This is a bug fix release.
-  * fix the build break on Solaris
-  * don't drop a whole trace in JSONFormatter when a field param is a function pointer which can not be serialized
-
-# 1.1.0
-This new release introduces:
-  * several fixes:
-    * a fix for a race condition on entry formatting
-    * proper cleanup of previously used entries before putting them back in the pool
-    * the extra new line at the end of message in text formatter has been removed
-  * a new global public API to check if a level is activated: IsLevelEnabled
-  * the following methods have been added to the Logger object
-    * IsLevelEnabled
-    * SetFormatter
-    * SetOutput
-    * ReplaceHooks
-  * introduction of go module
-  * an indent configuration for the json formatter
-  * output colour support for windows
-  * the field sort function is now configurable for text formatter
-  * the CLICOLOR and CLICOLOR\_FORCE environment variable support in text formater
-
-# 1.0.6
-
-This new release introduces:
-  * a new api WithTime which allows to easily force the time of the log entry
-    which is mostly useful for logger wrapper
-  * a fix reverting the immutability of the entry given as parameter to the hooks
-    a new configuration field of the json formatter in order to put all the fields
-    in a nested dictionnary
-  * a new SetOutput method in the Logger
-  * a new configuration of the textformatter to configure the name of the default keys
-  * a new configuration of the text formatter to disable the level truncation
-
-# 1.0.5
-
-* Fix hooks race (#707)
-* Fix panic deadlock (#695)
-
-# 1.0.4
-
-* Fix race when adding hooks (#612)
-* Fix terminal check in AppEngine (#635)
-
-# 1.0.3
-
-* Replace example files with testable examples
-
-# 1.0.2
-
-* bug: quote non-string values in text formatter (#583)
-* Make (*Logger) SetLevel a public method
-
-# 1.0.1
-
-* bug: fix escaping in text formatter (#575)
-
-# 1.0.0
-
-* Officially changed name to lower-case
-* bug: colors on Windows 10 (#541)
-* bug: fix race in accessing level (#512)
-
-# 0.11.5
-
-* feature: add writer and writerlevel to entry (#372)
-
-# 0.11.4
-
-* bug: fix undefined variable on solaris (#493)
-
-# 0.11.3
-
-* formatter: configure quoting of empty values (#484)
-* formatter: configure quoting character (default is `"`) (#484)
-* bug: fix not importing io correctly in non-linux environments (#481)
-
-# 0.11.2
-
-* bug: fix windows terminal detection (#476)
-
-# 0.11.1
-
-* bug: fix tty detection with custom out (#471)
-
-# 0.11.0
-
-* performance: Use bufferpool to allocate (#370)
-* terminal: terminal detection for app-engine (#343)
-* feature: exit handler (#375)
-
-# 0.10.0
-
-* feature: Add a test hook (#180)
-* feature: `ParseLevel` is now case-insensitive (#326)
-* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)
-* performance: avoid re-allocations on `WithFields` (#335)
-
-# 0.9.0
-
-* logrus/text_formatter: don't emit empty msg
-* logrus/hooks/airbrake: move out of main repository
-* logrus/hooks/sentry: move out of main repository
-* logrus/hooks/papertrail: move out of main repository
-* logrus/hooks/bugsnag: move out of main repository
-* logrus/core: run tests with `-race`
-* logrus/core: detect TTY based on `stderr`
-* logrus/core: support `WithError` on logger
-* logrus/core: Solaris support
-
-# 0.8.7
-
-* logrus/core: fix possible race (#216)
-* logrus/doc: small typo fixes and doc improvements
-
-
-# 0.8.6
-
-* hooks/raven: allow passing an initialized client
-
-# 0.8.5
-
-* logrus/core: revert #208
-
-# 0.8.4
-
-* formatter/text: fix data race (#218)
-
-# 0.8.3
-
-* logrus/core: fix entry log level (#208)
-* logrus/core: improve performance of text formatter by 40%
-* logrus/core: expose `LevelHooks` type
-* logrus/core: add support for DragonflyBSD and NetBSD
-* formatter/text: print structs more verbosely
-
-# 0.8.2
-
-* logrus: fix more Fatal family functions
-
-# 0.8.1
-
-* logrus: fix not exiting on `Fatalf` and `Fatalln`
-
-# 0.8.0
-
-* logrus: defaults to stderr instead of stdout
-* hooks/sentry: add special field for `*http.Request`
-* formatter/text: ignore Windows for colors
-
-# 0.7.3
-
-* formatter/\*: allow configuration of timestamp layout
-
-# 0.7.2
-
-* formatter/text: Add configuration option for time format (#158)
diff --git a/vendor/github.com/sirupsen/logrus/README.md b/vendor/github.com/sirupsen/logrus/README.md
deleted file mode 100644
index a4796eb..0000000
--- a/vendor/github.com/sirupsen/logrus/README.md
+++ /dev/null
@@ -1,495 +0,0 @@
-# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/sirupsen/logrus.svg?branch=master)](https://travis-ci.org/sirupsen/logrus)&nbsp;[![GoDoc](https://godoc.org/github.com/sirupsen/logrus?status.svg)](https://godoc.org/github.com/sirupsen/logrus)
-
-Logrus is a structured logger for Go (golang), completely API compatible with
-the standard library logger.
-
-**Seeing weird case-sensitive problems?** It's in the past been possible to
-import Logrus as both upper- and lower-case. Due to the Go package environment,
-this caused issues in the community and we needed a standard. Some environments
-experienced problems with the upper-case variant, so the lower-case was decided.
-Everything using `logrus` will need to use the lower-case:
-`github.com/sirupsen/logrus`. Any package that isn't, should be changed.
-
-To fix Glide, see [these
-comments](https://github.com/sirupsen/logrus/issues/553#issuecomment-306591437).
-For an in-depth explanation of the casing issue, see [this
-comment](https://github.com/sirupsen/logrus/issues/570#issuecomment-313933276).
-
-**Are you interested in assisting in maintaining Logrus?** Currently I have a
-lot of obligations, and I am unable to provide Logrus with the maintainership it
-needs. If you'd like to help, please reach out to me at `simon at author's
-username dot com`.
-
-Nicely color-coded in development (when a TTY is attached, otherwise just
-plain text):
-
-![Colored](http://i.imgur.com/PY7qMwd.png)
-
-With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash
-or Splunk:
-
-```json
-{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
-ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
-
-{"level":"warning","msg":"The group's number increased tremendously!",
-"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
-"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
-"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
-
-{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
-"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
-```
-
-With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not
-attached, the output is compatible with the
-[logfmt](http://godoc.org/github.com/kr/logfmt) format:
-
-```text
-time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
-time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
-time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
-time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
-time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
-time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
-```
-To ensure this behaviour even if a TTY is attached, set your formatter as follows:
-
-```go
-        log.SetFormatter(&log.TextFormatter{
-                DisableColors: true,
-                FullTimestamp: true,
-        })
-```
-
-#### Logging Method Name
-
-If you wish to add the calling method as a field, instruct the logger via:
-```go
-log.SetReportCaller(true)
-```
-This adds the caller as 'method' like so:
-
-```json
-{"animal":"penguin","level":"fatal","method":"github.com/sirupsen/arcticcreatures.migrate","msg":"a penguin swims by",
-"time":"2014-03-10 19:57:38.562543129 -0400 EDT"}
-```
-
-```text
-time="2015-03-26T01:27:38-04:00" level=fatal method=github.com/sirupsen/arcticcreatures.migrate msg="a penguin swims by" animal=penguin
-```
-Note that this does add measurable overhead - the cost will depend on the version of Go, but is
-between 20 and 40% in recent tests with 1.6 and 1.7.  You can validate this in your
-environment via benchmarks: 
-```
-go test -bench=.*CallerTracing
-```
-
-
-#### Case-sensitivity
-
-The organization's name was changed to lower-case--and this will not be changed
-back. If you are getting import conflicts due to case sensitivity, please use
-the lower-case import: `github.com/sirupsen/logrus`.
-
-#### Example
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-```go
-package main
-
-import (
-  log "github.com/sirupsen/logrus"
-)
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-  }).Info("A walrus appears")
-}
-```
-
-Note that it's completely api-compatible with the stdlib logger, so you can
-replace your `log` imports everywhere with `log "github.com/sirupsen/logrus"`
-and you'll now have the flexibility of Logrus. You can customize it all you
-want:
-
-```go
-package main
-
-import (
-  "os"
-  log "github.com/sirupsen/logrus"
-)
-
-func init() {
-  // Log as JSON instead of the default ASCII formatter.
-  log.SetFormatter(&log.JSONFormatter{})
-
-  // Output to stdout instead of the default stderr
-  // Can be any io.Writer, see below for File example
-  log.SetOutput(os.Stdout)
-
-  // Only log the warning severity or above.
-  log.SetLevel(log.WarnLevel)
-}
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 122,
-  }).Warn("The group's number increased tremendously!")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 100,
-  }).Fatal("The ice breaks!")
-
-  // A common pattern is to re-use fields between logging statements by re-using
-  // the logrus.Entry returned from WithFields()
-  contextLogger := log.WithFields(log.Fields{
-    "common": "this is a common field",
-    "other": "I also should be logged always",
-  })
-
-  contextLogger.Info("I'll be logged with common and other field")
-  contextLogger.Info("Me too")
-}
-```
-
-For more advanced usage such as logging to multiple locations from the same
-application, you can also create an instance of the `logrus` Logger:
-
-```go
-package main
-
-import (
-  "os"
-  "github.com/sirupsen/logrus"
-)
-
-// Create a new instance of the logger. You can have any number of instances.
-var log = logrus.New()
-
-func main() {
-  // The API for setting attributes is a little different than the package level
-  // exported logger. See Godoc.
-  log.Out = os.Stdout
-
-  // You could set this to any `io.Writer` such as a file
-  // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
-  // if err == nil {
-  //  log.Out = file
-  // } else {
-  //  log.Info("Failed to log to file, using default stderr")
-  // }
-
-  log.WithFields(logrus.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-}
-```
-
-#### Fields
-
-Logrus encourages careful, structured logging through logging fields instead of
-long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
-to send event %s to topic %s with key %d")`, you should log the much more
-discoverable:
-
-```go
-log.WithFields(log.Fields{
-  "event": event,
-  "topic": topic,
-  "key": key,
-}).Fatal("Failed to send event")
-```
-
-We've found this API forces you to think about logging in a way that produces
-much more useful logging messages. We've been in countless situations where just
-a single added field to a log statement that was already there would've saved us
-hours. The `WithFields` call is optional.
-
-In general, with Logrus using any of the `printf`-family functions should be
-seen as a hint you should add a field, however, you can still use the
-`printf`-family functions with Logrus.
-
-#### Default Fields
-
-Often it's helpful to have fields _always_ attached to log statements in an
-application or parts of one. For example, you may want to always log the
-`request_id` and `user_ip` in the context of a request. Instead of writing
-`log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})` on
-every line, you can create a `logrus.Entry` to pass around instead:
-
-```go
-requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})
-requestLogger.Info("something happened on that request") # will log request_id and user_ip
-requestLogger.Warn("something not great happened")
-```
-
-#### Hooks
-
-You can add hooks for logging levels. For example to send errors to an exception
-tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
-multiple places simultaneously, e.g. syslog.
-
-Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
-`init`:
-
-```go
-import (
-  log "github.com/sirupsen/logrus"
-  "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake"
-  logrus_syslog "github.com/sirupsen/logrus/hooks/syslog"
-  "log/syslog"
-)
-
-func init() {
-
-  // Use the Airbrake hook to report errors that have Error severity or above to
-  // an exception tracker. You can create custom hooks, see the Hooks section.
-  log.AddHook(airbrake.NewHook(123, "xyz", "production"))
-
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-  if err != nil {
-    log.Error("Unable to connect to local syslog daemon")
-  } else {
-    log.AddHook(hook)
-  }
-}
-```
-Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
-
-A list of currently known of service hook can be found in this wiki [page](https://github.com/sirupsen/logrus/wiki/Hooks)
-
-
-#### Level logging
-
-Logrus has seven logging levels: Trace, Debug, Info, Warning, Error, Fatal and Panic.
-
-```go
-log.Trace("Something very low level.")
-log.Debug("Useful debugging information.")
-log.Info("Something noteworthy happened!")
-log.Warn("You should probably take a look at this.")
-log.Error("Something failed but I'm not quitting.")
-// Calls os.Exit(1) after logging
-log.Fatal("Bye.")
-// Calls panic() after logging
-log.Panic("I'm bailing.")
-```
-
-You can set the logging level on a `Logger`, then it will only log entries with
-that severity or anything above it:
-
-```go
-// Will log anything that is info or above (warn, error, fatal, panic). Default.
-log.SetLevel(log.InfoLevel)
-```
-
-It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
-environment if your application has that.
-
-#### Entries
-
-Besides the fields added with `WithField` or `WithFields` some fields are
-automatically added to all logging events:
-
-1. `time`. The timestamp when the entry was created.
-2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
-   the `AddFields` call. E.g. `Failed to send event.`
-3. `level`. The logging level. E.g. `info`.
-
-#### Environments
-
-Logrus has no notion of environment.
-
-If you wish for hooks and formatters to only be used in specific environments,
-you should handle that yourself. For example, if your application has a global
-variable `Environment`, which is a string representation of the environment you
-could do:
-
-```go
-import (
-  log "github.com/sirupsen/logrus"
-)
-
-init() {
-  // do something here to set environment depending on an environment variable
-  // or command-line flag
-  if Environment == "production" {
-    log.SetFormatter(&log.JSONFormatter{})
-  } else {
-    // The TextFormatter is default, you don't actually have to do this.
-    log.SetFormatter(&log.TextFormatter{})
-  }
-}
-```
-
-This configuration is how `logrus` was intended to be used, but JSON in
-production is mostly only useful if you do log aggregation with tools like
-Splunk or Logstash.
-
-#### Formatters
-
-The built-in logging formatters are:
-
-* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
-  without colors.
-  * *Note:* to force colored output when there is no TTY, set the `ForceColors`
-    field to `true`.  To force no colored output even if there is a TTY  set the
-    `DisableColors` field to `true`. For Windows, see
-    [github.com/mattn/go-colorable](https://github.com/mattn/go-colorable).
-  * When colors are enabled, levels are truncated to 4 characters by default. To disable
-    truncation set the `DisableLevelTruncation` field to `true`.
-  * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#TextFormatter).
-* `logrus.JSONFormatter`. Logs fields as JSON.
-  * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#JSONFormatter).
-
-Third party logging formatters:
-
-* [`FluentdFormatter`](https://github.com/joonix/log). Formats entries that can be parsed by Kubernetes and Google Container Engine.
-* [`GELF`](https://github.com/fabienm/go-logrus-formatters). Formats entries so they comply to Graylog's [GELF 1.1 specification](http://docs.graylog.org/en/2.4/pages/gelf.html).
-* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events.
-* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
-* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
-* [`nested-logrus-formatter`](https://github.com/antonfisher/nested-logrus-formatter). Converts logrus fields to a nested structure.
-
-You can define your formatter by implementing the `Formatter` interface,
-requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
-`Fields` type (`map[string]interface{}`) with all your fields as well as the
-default ones (see Entries section above):
-
-```go
-type MyJSONFormatter struct {
-}
-
-log.SetFormatter(new(MyJSONFormatter))
-
-func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
-  // Note this doesn't include Time, Level and Message which are available on
-  // the Entry. Consult `godoc` on information about those fields or read the
-  // source of the official loggers.
-  serialized, err := json.Marshal(entry.Data)
-    if err != nil {
-      return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-    }
-  return append(serialized, '\n'), nil
-}
-```
-
-#### Logger as an `io.Writer`
-
-Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
-
-```go
-w := logger.Writer()
-defer w.Close()
-
-srv := http.Server{
-    // create a stdlib log.Logger that writes to
-    // logrus.Logger.
-    ErrorLog: log.New(w, "", 0),
-}
-```
-
-Each line written to that writer will be printed the usual way, using formatters
-and hooks. The level for those entries is `info`.
-
-This means that we can override the standard library logger easily:
-
-```go
-logger := logrus.New()
-logger.Formatter = &logrus.JSONFormatter{}
-
-// Use logrus for standard log output
-// Note that `log` here references stdlib's log
-// Not logrus imported under the name `log`.
-log.SetOutput(logger.Writer())
-```
-
-#### Rotation
-
-Log rotation is not provided with Logrus. Log rotation should be done by an
-external program (like `logrotate(8)`) that can compress and delete old log
-entries. It should not be a feature of the application-level logger.
-
-#### Tools
-
-| Tool | Description |
-| ---- | ----------- |
-|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
-|[Logrus Viper Helper](https://github.com/heirko/go-contrib/tree/master/logrusHelper)|An Helper around Logrus to wrap with spf13/Viper to load configuration with fangs! And to simplify Logrus configuration use some behavior of [Logrus Mate](https://github.com/gogap/logrus_mate). [sample](https://github.com/heirko/iris-contrib/blob/master/middleware/logrus-logger/example) |
-
-#### Testing
-
-Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
-
-* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook
-* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
-
-```go
-import(
-  "github.com/sirupsen/logrus"
-  "github.com/sirupsen/logrus/hooks/test"
-  "github.com/stretchr/testify/assert"
-  "testing"
-)
-
-func TestSomething(t*testing.T){
-  logger, hook := test.NewNullLogger()
-  logger.Error("Helloerror")
-
-  assert.Equal(t, 1, len(hook.Entries))
-  assert.Equal(t, logrus.ErrorLevel, hook.LastEntry().Level)
-  assert.Equal(t, "Helloerror", hook.LastEntry().Message)
-
-  hook.Reset()
-  assert.Nil(t, hook.LastEntry())
-}
-```
-
-#### Fatal handlers
-
-Logrus can register one or more functions that will be called when any `fatal`
-level message is logged. The registered handlers will be executed before
-logrus performs a `os.Exit(1)`. This behavior may be helpful if callers need
-to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted.
-
-```
-...
-handler := func() {
-  // gracefully shutdown something...
-}
-logrus.RegisterExitHandler(handler)
-...
-```
-
-#### Thread safety
-
-By default, Logger is protected by a mutex for concurrent writes. The mutex is held when calling hooks and writing logs.
-If you are sure such locking is not needed, you can call logger.SetNoLock() to disable the locking.
-
-Situation when locking is not needed includes:
-
-* You have no hooks registered, or hooks calling is already thread-safe.
-
-* Writing to logger.Out is already thread-safe, for example:
-
-  1) logger.Out is protected by locks.
-
-  2) logger.Out is a os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allow multi-thread/multi-process writing)
-
-     (Refer to http://www.notthewizard.com/2014/06/17/are-files-appends-really-atomic/)
diff --git a/vendor/github.com/sirupsen/logrus/alt_exit.go b/vendor/github.com/sirupsen/logrus/alt_exit.go
deleted file mode 100644
index 8fd189e..0000000
--- a/vendor/github.com/sirupsen/logrus/alt_exit.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package logrus
-
-// The following code was sourced and modified from the
-// https://github.com/tebeka/atexit package governed by the following license:
-//
-// Copyright (c) 2012 Miki Tebeka <miki.tebeka@gmail.com>.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-// the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 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.
-
-import (
-        "fmt"
-        "os"
-)
-
-var handlers = []func(){}
-
-func runHandler(handler func()) {
-        defer func() {
-                if err := recover(); err != nil {
-                        fmt.Fprintln(os.Stderr, "Error: Logrus exit handler error:", err)
-                }
-        }()
-
-        handler()
-}
-
-func runHandlers() {
-        for _, handler := range handlers {
-                runHandler(handler)
-        }
-}
-
-// Exit runs all the Logrus atexit handlers and then terminates the program using os.Exit(code)
-func Exit(code int) {
-        runHandlers()
-        os.Exit(code)
-}
-
-// RegisterExitHandler appends a Logrus Exit handler to the list of handlers,
-// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
-// any Fatal log entry is made.
-//
-// This method is useful when a caller wishes to use logrus to log a fatal
-// message but also needs to gracefully shutdown. An example usecase could be
-// closing database connections, or sending a alert that the application is
-// closing.
-func RegisterExitHandler(handler func()) {
-        handlers = append(handlers, handler)
-}
-
-// DeferExitHandler prepends a Logrus Exit handler to the list of handlers,
-// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
-// any Fatal log entry is made.
-//
-// This method is useful when a caller wishes to use logrus to log a fatal
-// message but also needs to gracefully shutdown. An example usecase could be
-// closing database connections, or sending a alert that the application is
-// closing.
-func DeferExitHandler(handler func()) {
-        handlers = append([]func(){handler}, handlers...)
-}
diff --git a/vendor/github.com/sirupsen/logrus/appveyor.yml b/vendor/github.com/sirupsen/logrus/appveyor.yml
deleted file mode 100644
index 96c2ce1..0000000
--- a/vendor/github.com/sirupsen/logrus/appveyor.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-version: "{build}"

-platform: x64

-clone_folder: c:\gopath\src\github.com\sirupsen\logrus

-environment:  

-  GOPATH: c:\gopath

-branches:  

-  only:

-    - master

-install:  

-  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%

-  - go version

-build_script:  

-  - go get -t

-  - go test

diff --git a/vendor/github.com/sirupsen/logrus/doc.go b/vendor/github.com/sirupsen/logrus/doc.go
deleted file mode 100644
index da67aba..0000000
--- a/vendor/github.com/sirupsen/logrus/doc.go
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-Package logrus is a structured logger for Go, completely API compatible with the standard library logger.
-
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-  package main
-
-  import (
-    log "github.com/sirupsen/logrus"
-  )
-
-  func main() {
-    log.WithFields(log.Fields{
-      "animal": "walrus",
-      "number": 1,
-      "size":   10,
-    }).Info("A walrus appears")
-  }
-
-Output:
-  time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10
-
-For a full guide visit https://github.com/sirupsen/logrus
-*/
-package logrus
diff --git a/vendor/github.com/sirupsen/logrus/entry.go b/vendor/github.com/sirupsen/logrus/entry.go
deleted file mode 100644
index 63e2558..0000000
--- a/vendor/github.com/sirupsen/logrus/entry.go
+++ /dev/null
@@ -1,407 +0,0 @@
-package logrus
-
-import (
-        "bytes"
-        "context"
-        "fmt"
-        "os"
-        "reflect"
-        "runtime"
-        "strings"
-        "sync"
-        "time"
-)
-
-var (
-        bufferPool *sync.Pool
-
-        // qualified package name, cached at first use
-        logrusPackage string
-
-        // Positions in the call stack when tracing to report the calling method
-        minimumCallerDepth int
-
-        // Used for caller information initialisation
-        callerInitOnce sync.Once
-)
-
-const (
-        maximumCallerDepth int = 25
-        knownLogrusFrames  int = 4
-)
-
-func init() {
-        bufferPool = &sync.Pool{
-                New: func() interface{} {
-                        return new(bytes.Buffer)
-                },
-        }
-
-        // start at the bottom of the stack before the package-name cache is primed
-        minimumCallerDepth = 1
-}
-
-// Defines the key when adding errors using WithError.
-var ErrorKey = "error"
-
-// An entry is the final or intermediate Logrus logging entry. It contains all
-// the fields passed with WithField{,s}. It's finally logged when Trace, Debug,
-// Info, Warn, Error, Fatal or Panic is called on it. These objects can be
-// reused and passed around as much as you wish to avoid field duplication.
-type Entry struct {
-        Logger *Logger
-
-        // Contains all the fields set by the user.
-        Data Fields
-
-        // Time at which the log entry was created
-        Time time.Time
-
-        // Level the log entry was logged at: Trace, Debug, Info, Warn, Error, Fatal or Panic
-        // This field will be set on entry firing and the value will be equal to the one in Logger struct field.
-        Level Level
-
-        // Calling method, with package name
-        Caller *runtime.Frame
-
-        // Message passed to Trace, Debug, Info, Warn, Error, Fatal or Panic
-        Message string
-
-        // When formatter is called in entry.log(), a Buffer may be set to entry
-        Buffer *bytes.Buffer
-
-        // Contains the context set by the user. Useful for hook processing etc.
-        Context context.Context
-
-        // err may contain a field formatting error
-        err string
-}
-
-func NewEntry(logger *Logger) *Entry {
-        return &Entry{
-                Logger: logger,
-                // Default is three fields, plus one optional.  Give a little extra room.
-                Data: make(Fields, 6),
-        }
-}
-
-// Returns the string representation from the reader and ultimately the
-// formatter.
-func (entry *Entry) String() (string, error) {
-        serialized, err := entry.Logger.Formatter.Format(entry)
-        if err != nil {
-                return "", err
-        }
-        str := string(serialized)
-        return str, nil
-}
-
-// Add an error as single field (using the key defined in ErrorKey) to the Entry.
-func (entry *Entry) WithError(err error) *Entry {
-        return entry.WithField(ErrorKey, err)
-}
-
-// Add a context to the Entry.
-func (entry *Entry) WithContext(ctx context.Context) *Entry {
-        return &Entry{Logger: entry.Logger, Data: entry.Data, Time: entry.Time, err: entry.err, Context: ctx}
-}
-
-// Add a single field to the Entry.
-func (entry *Entry) WithField(key string, value interface{}) *Entry {
-        return entry.WithFields(Fields{key: value})
-}
-
-// Add a map of fields to the Entry.
-func (entry *Entry) WithFields(fields Fields) *Entry {
-        data := make(Fields, len(entry.Data)+len(fields))
-        for k, v := range entry.Data {
-                data[k] = v
-        }
-        fieldErr := entry.err
-        for k, v := range fields {
-                isErrField := false
-                if t := reflect.TypeOf(v); t != nil {
-                        switch t.Kind() {
-                        case reflect.Func:
-                                isErrField = true
-                        case reflect.Ptr:
-                                isErrField = t.Elem().Kind() == reflect.Func
-                        }
-                }
-                if isErrField {
-                        tmp := fmt.Sprintf("can not add field %q", k)
-                        if fieldErr != "" {
-                                fieldErr = entry.err + ", " + tmp
-                        } else {
-                                fieldErr = tmp
-                        }
-                } else {
-                        data[k] = v
-                }
-        }
-        return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context}
-}
-
-// Overrides the time of the Entry.
-func (entry *Entry) WithTime(t time.Time) *Entry {
-        return &Entry{Logger: entry.Logger, Data: entry.Data, Time: t, err: entry.err, Context: entry.Context}
-}
-
-// getPackageName reduces a fully qualified function name to the package name
-// There really ought to be to be a better way...
-func getPackageName(f string) string {
-        for {
-                lastPeriod := strings.LastIndex(f, ".")
-                lastSlash := strings.LastIndex(f, "/")
-                if lastPeriod > lastSlash {
-                        f = f[:lastPeriod]
-                } else {
-                        break
-                }
-        }
-
-        return f
-}
-
-// getCaller retrieves the name of the first non-logrus calling function
-func getCaller() *runtime.Frame {
-
-        // cache this package's fully-qualified name
-        callerInitOnce.Do(func() {
-                pcs := make([]uintptr, 2)
-                _ = runtime.Callers(0, pcs)
-                logrusPackage = getPackageName(runtime.FuncForPC(pcs[1]).Name())
-
-                // now that we have the cache, we can skip a minimum count of known-logrus functions
-                // XXX this is dubious, the number of frames may vary
-                minimumCallerDepth = knownLogrusFrames
-        })
-
-        // Restrict the lookback frames to avoid runaway lookups
-        pcs := make([]uintptr, maximumCallerDepth)
-        depth := runtime.Callers(minimumCallerDepth, pcs)
-        frames := runtime.CallersFrames(pcs[:depth])
-
-        for f, again := frames.Next(); again; f, again = frames.Next() {
-                pkg := getPackageName(f.Function)
-
-                // If the caller isn't part of this package, we're done
-                if pkg != logrusPackage {
-                        return &f
-                }
-        }
-
-        // if we got here, we failed to find the caller's context
-        return nil
-}
-
-func (entry Entry) HasCaller() (has bool) {
-        return entry.Logger != nil &&
-                entry.Logger.ReportCaller &&
-                entry.Caller != nil
-}
-
-// This function is not declared with a pointer value because otherwise
-// race conditions will occur when using multiple goroutines
-func (entry Entry) log(level Level, msg string) {
-        var buffer *bytes.Buffer
-
-        // Default to now, but allow users to override if they want.
-        //
-        // We don't have to worry about polluting future calls to Entry#log()
-        // with this assignment because this function is declared with a
-        // non-pointer receiver.
-        if entry.Time.IsZero() {
-                entry.Time = time.Now()
-        }
-
-        entry.Level = level
-        entry.Message = msg
-        if entry.Logger.ReportCaller {
-                entry.Caller = getCaller()
-        }
-
-        entry.fireHooks()
-
-        buffer = bufferPool.Get().(*bytes.Buffer)
-        buffer.Reset()
-        defer bufferPool.Put(buffer)
-        entry.Buffer = buffer
-
-        entry.write()
-
-        entry.Buffer = nil
-
-        // To avoid Entry#log() returning a value that only would make sense for
-        // panic() to use in Entry#Panic(), we avoid the allocation by checking
-        // directly here.
-        if level <= PanicLevel {
-                panic(&entry)
-        }
-}
-
-func (entry *Entry) fireHooks() {
-        entry.Logger.mu.Lock()
-        defer entry.Logger.mu.Unlock()
-        err := entry.Logger.Hooks.Fire(entry.Level, entry)
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
-        }
-}
-
-func (entry *Entry) write() {
-        entry.Logger.mu.Lock()
-        defer entry.Logger.mu.Unlock()
-        serialized, err := entry.Logger.Formatter.Format(entry)
-        if err != nil {
-                fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
-        } else {
-                _, err = entry.Logger.Out.Write(serialized)
-                if err != nil {
-                        fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
-                }
-        }
-}
-
-func (entry *Entry) Log(level Level, args ...interface{}) {
-        if entry.Logger.IsLevelEnabled(level) {
-                entry.log(level, fmt.Sprint(args...))
-        }
-}
-
-func (entry *Entry) Trace(args ...interface{}) {
-        entry.Log(TraceLevel, args...)
-}
-
-func (entry *Entry) Debug(args ...interface{}) {
-        entry.Log(DebugLevel, args...)
-}
-
-func (entry *Entry) Print(args ...interface{}) {
-        entry.Info(args...)
-}
-
-func (entry *Entry) Info(args ...interface{}) {
-        entry.Log(InfoLevel, args...)
-}
-
-func (entry *Entry) Warn(args ...interface{}) {
-        entry.Log(WarnLevel, args...)
-}
-
-func (entry *Entry) Warning(args ...interface{}) {
-        entry.Warn(args...)
-}
-
-func (entry *Entry) Error(args ...interface{}) {
-        entry.Log(ErrorLevel, args...)
-}
-
-func (entry *Entry) Fatal(args ...interface{}) {
-        entry.Log(FatalLevel, args...)
-        entry.Logger.Exit(1)
-}
-
-func (entry *Entry) Panic(args ...interface{}) {
-        entry.Log(PanicLevel, args...)
-        panic(fmt.Sprint(args...))
-}
-
-// Entry Printf family functions
-
-func (entry *Entry) Logf(level Level, format string, args ...interface{}) {
-        if entry.Logger.IsLevelEnabled(level) {
-                entry.Log(level, fmt.Sprintf(format, args...))
-        }
-}
-
-func (entry *Entry) Tracef(format string, args ...interface{}) {
-        entry.Logf(TraceLevel, format, args...)
-}
-
-func (entry *Entry) Debugf(format string, args ...interface{}) {
-        entry.Logf(DebugLevel, format, args...)
-}
-
-func (entry *Entry) Infof(format string, args ...interface{}) {
-        entry.Logf(InfoLevel, format, args...)
-}
-
-func (entry *Entry) Printf(format string, args ...interface{}) {
-        entry.Infof(format, args...)
-}
-
-func (entry *Entry) Warnf(format string, args ...interface{}) {
-        entry.Logf(WarnLevel, format, args...)
-}
-
-func (entry *Entry) Warningf(format string, args ...interface{}) {
-        entry.Warnf(format, args...)
-}
-
-func (entry *Entry) Errorf(format string, args ...interface{}) {
-        entry.Logf(ErrorLevel, format, args...)
-}
-
-func (entry *Entry) Fatalf(format string, args ...interface{}) {
-        entry.Logf(FatalLevel, format, args...)
-        entry.Logger.Exit(1)
-}
-
-func (entry *Entry) Panicf(format string, args ...interface{}) {
-        entry.Logf(PanicLevel, format, args...)
-}
-
-// Entry Println family functions
-
-func (entry *Entry) Logln(level Level, args ...interface{}) {
-        if entry.Logger.IsLevelEnabled(level) {
-                entry.Log(level, entry.sprintlnn(args...))
-        }
-}
-
-func (entry *Entry) Traceln(args ...interface{}) {
-        entry.Logln(TraceLevel, args...)
-}
-
-func (entry *Entry) Debugln(args ...interface{}) {
-        entry.Logln(DebugLevel, args...)
-}
-
-func (entry *Entry) Infoln(args ...interface{}) {
-        entry.Logln(InfoLevel, args...)
-}
-
-func (entry *Entry) Println(args ...interface{}) {
-        entry.Infoln(args...)
-}
-
-func (entry *Entry) Warnln(args ...interface{}) {
-        entry.Logln(WarnLevel, args...)
-}
-
-func (entry *Entry) Warningln(args ...interface{}) {
-        entry.Warnln(args...)
-}
-
-func (entry *Entry) Errorln(args ...interface{}) {
-        entry.Logln(ErrorLevel, args...)
-}
-
-func (entry *Entry) Fatalln(args ...interface{}) {
-        entry.Logln(FatalLevel, args...)
-        entry.Logger.Exit(1)
-}
-
-func (entry *Entry) Panicln(args ...interface{}) {
-        entry.Logln(PanicLevel, args...)
-}
-
-// Sprintlnn => Sprint no newline. This is to get the behavior of how
-// fmt.Sprintln where spaces are always added between operands, regardless of
-// their type. Instead of vendoring the Sprintln implementation to spare a
-// string allocation, we do the simplest thing.
-func (entry *Entry) sprintlnn(args ...interface{}) string {
-        msg := fmt.Sprintln(args...)
-        return msg[:len(msg)-1]
-}
diff --git a/vendor/github.com/sirupsen/logrus/exported.go b/vendor/github.com/sirupsen/logrus/exported.go
deleted file mode 100644
index 62fc2f2..0000000
--- a/vendor/github.com/sirupsen/logrus/exported.go
+++ /dev/null
@@ -1,225 +0,0 @@
-package logrus
-
-import (
-        "context"
-        "io"
-        "time"
-)
-
-var (
-        // std is the name of the standard logger in stdlib `log`
-        std = New()
-)
-
-func StandardLogger() *Logger {
-        return std
-}
-
-// SetOutput sets the standard logger output.
-func SetOutput(out io.Writer) {
-        std.SetOutput(out)
-}
-
-// SetFormatter sets the standard logger formatter.
-func SetFormatter(formatter Formatter) {
-        std.SetFormatter(formatter)
-}
-
-// SetReportCaller sets whether the standard logger will include the calling
-// method as a field.
-func SetReportCaller(include bool) {
-        std.SetReportCaller(include)
-}
-
-// SetLevel sets the standard logger level.
-func SetLevel(level Level) {
-        std.SetLevel(level)
-}
-
-// GetLevel returns the standard logger level.
-func GetLevel() Level {
-        return std.GetLevel()
-}
-
-// IsLevelEnabled checks if the log level of the standard logger is greater than the level param
-func IsLevelEnabled(level Level) bool {
-        return std.IsLevelEnabled(level)
-}
-
-// AddHook adds a hook to the standard logger hooks.
-func AddHook(hook Hook) {
-        std.AddHook(hook)
-}
-
-// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
-func WithError(err error) *Entry {
-        return std.WithField(ErrorKey, err)
-}
-
-// WithContext creates an entry from the standard logger and adds a context to it.
-func WithContext(ctx context.Context) *Entry {
-        return std.WithContext(ctx)
-}
-
-// WithField creates an entry from the standard logger and adds a field to
-// it. If you want multiple fields, use `WithFields`.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithField(key string, value interface{}) *Entry {
-        return std.WithField(key, value)
-}
-
-// WithFields creates an entry from the standard logger and adds multiple
-// fields to it. This is simply a helper for `WithField`, invoking it
-// once for each field.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithFields(fields Fields) *Entry {
-        return std.WithFields(fields)
-}
-
-// WithTime creats an entry from the standard logger and overrides the time of
-// logs generated with it.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithTime(t time.Time) *Entry {
-        return std.WithTime(t)
-}
-
-// Trace logs a message at level Trace on the standard logger.
-func Trace(args ...interface{}) {
-        std.Trace(args...)
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func Debug(args ...interface{}) {
-        std.Debug(args...)
-}
-
-// Print logs a message at level Info on the standard logger.
-func Print(args ...interface{}) {
-        std.Print(args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func Info(args ...interface{}) {
-        std.Info(args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func Warn(args ...interface{}) {
-        std.Warn(args...)
-}
-
-// Warning logs a message at level Warn on the standard logger.
-func Warning(args ...interface{}) {
-        std.Warning(args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func Error(args ...interface{}) {
-        std.Error(args...)
-}
-
-// Panic logs a message at level Panic on the standard logger.
-func Panic(args ...interface{}) {
-        std.Panic(args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
-func Fatal(args ...interface{}) {
-        std.Fatal(args...)
-}
-
-// Tracef logs a message at level Trace on the standard logger.
-func Tracef(format string, args ...interface{}) {
-        std.Tracef(format, args...)
-}
-
-// Debugf logs a message at level Debug on the standard logger.
-func Debugf(format string, args ...interface{}) {
-        std.Debugf(format, args...)
-}
-
-// Printf logs a message at level Info on the standard logger.
-func Printf(format string, args ...interface{}) {
-        std.Printf(format, args...)
-}
-
-// Infof logs a message at level Info on the standard logger.
-func Infof(format string, args ...interface{}) {
-        std.Infof(format, args...)
-}
-
-// Warnf logs a message at level Warn on the standard logger.
-func Warnf(format string, args ...interface{}) {
-        std.Warnf(format, args...)
-}
-
-// Warningf logs a message at level Warn on the standard logger.
-func Warningf(format string, args ...interface{}) {
-        std.Warningf(format, args...)
-}
-
-// Errorf logs a message at level Error on the standard logger.
-func Errorf(format string, args ...interface{}) {
-        std.Errorf(format, args...)
-}
-
-// Panicf logs a message at level Panic on the standard logger.
-func Panicf(format string, args ...interface{}) {
-        std.Panicf(format, args...)
-}
-
-// Fatalf logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
-func Fatalf(format string, args ...interface{}) {
-        std.Fatalf(format, args...)
-}
-
-// Traceln logs a message at level Trace on the standard logger.
-func Traceln(args ...interface{}) {
-        std.Traceln(args...)
-}
-
-// Debugln logs a message at level Debug on the standard logger.
-func Debugln(args ...interface{}) {
-        std.Debugln(args...)
-}
-
-// Println logs a message at level Info on the standard logger.
-func Println(args ...interface{}) {
-        std.Println(args...)
-}
-
-// Infoln logs a message at level Info on the standard logger.
-func Infoln(args ...interface{}) {
-        std.Infoln(args...)
-}
-
-// Warnln logs a message at level Warn on the standard logger.
-func Warnln(args ...interface{}) {
-        std.Warnln(args...)
-}
-
-// Warningln logs a message at level Warn on the standard logger.
-func Warningln(args ...interface{}) {
-        std.Warningln(args...)
-}
-
-// Errorln logs a message at level Error on the standard logger.
-func Errorln(args ...interface{}) {
-        std.Errorln(args...)
-}
-
-// Panicln logs a message at level Panic on the standard logger.
-func Panicln(args ...interface{}) {
-        std.Panicln(args...)
-}
-
-// Fatalln logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
-func Fatalln(args ...interface{}) {
-        std.Fatalln(args...)
-}
diff --git a/vendor/github.com/sirupsen/logrus/formatter.go b/vendor/github.com/sirupsen/logrus/formatter.go
deleted file mode 100644
index 4088837..0000000
--- a/vendor/github.com/sirupsen/logrus/formatter.go
+++ /dev/null
@@ -1,78 +0,0 @@
-package logrus
-
-import "time"
-
-// Default key names for the default fields
-const (
-        defaultTimestampFormat = time.RFC3339
-        FieldKeyMsg            = "msg"
-        FieldKeyLevel          = "level"
-        FieldKeyTime           = "time"
-        FieldKeyLogrusError    = "logrus_error"
-        FieldKeyFunc           = "func"
-        FieldKeyFile           = "file"
-)
-
-// The Formatter interface is used to implement a custom Formatter. It takes an
-// `Entry`. It exposes all the fields, including the default ones:
-//
-// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
-// * `entry.Data["time"]`. The timestamp.
-// * `entry.Data["level"]. The level the entry was logged at.
-//
-// Any additional fields added with `WithField` or `WithFields` are also in
-// `entry.Data`. Format is expected to return an array of bytes which are then
-// logged to `logger.Out`.
-type Formatter interface {
-        Format(*Entry) ([]byte, error)
-}
-
-// This is to not silently overwrite `time`, `msg`, `func` and `level` fields when
-// dumping it. If this code wasn't there doing:
-//
-//  logrus.WithField("level", 1).Info("hello")
-//
-// Would just silently drop the user provided level. Instead with this code
-// it'll logged as:
-//
-//  {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
-//
-// It's not exported because it's still using Data in an opinionated way. It's to
-// avoid code duplication between the two default formatters.
-func prefixFieldClashes(data Fields, fieldMap FieldMap, reportCaller bool) {
-        timeKey := fieldMap.resolve(FieldKeyTime)
-        if t, ok := data[timeKey]; ok {
-                data["fields."+timeKey] = t
-                delete(data, timeKey)
-        }
-
-        msgKey := fieldMap.resolve(FieldKeyMsg)
-        if m, ok := data[msgKey]; ok {
-                data["fields."+msgKey] = m
-                delete(data, msgKey)
-        }
-
-        levelKey := fieldMap.resolve(FieldKeyLevel)
-        if l, ok := data[levelKey]; ok {
-                data["fields."+levelKey] = l
-                delete(data, levelKey)
-        }
-
-        logrusErrKey := fieldMap.resolve(FieldKeyLogrusError)
-        if l, ok := data[logrusErrKey]; ok {
-                data["fields."+logrusErrKey] = l
-                delete(data, logrusErrKey)
-        }
-
-        // If reportCaller is not set, 'func' will not conflict.
-        if reportCaller {
-                funcKey := fieldMap.resolve(FieldKeyFunc)
-                if l, ok := data[funcKey]; ok {
-                        data["fields."+funcKey] = l
-                }
-                fileKey := fieldMap.resolve(FieldKeyFile)
-                if l, ok := data[fileKey]; ok {
-                        data["fields."+fileKey] = l
-                }
-        }
-}
diff --git a/vendor/github.com/sirupsen/logrus/go.mod b/vendor/github.com/sirupsen/logrus/go.mod
deleted file mode 100644
index 12fdf98..0000000
--- a/vendor/github.com/sirupsen/logrus/go.mod
+++ /dev/null
@@ -1,10 +0,0 @@
-module github.com/sirupsen/logrus
-
-require (
-        github.com/davecgh/go-spew v1.1.1 // indirect
-        github.com/konsorten/go-windows-terminal-sequences v1.0.1
-        github.com/pmezard/go-difflib v1.0.0 // indirect
-        github.com/stretchr/objx v0.1.1 // indirect
-        github.com/stretchr/testify v1.2.2
-        golang.org/x/sys v0.0.0-20190422165155-953cdadca894
-)
diff --git a/vendor/github.com/sirupsen/logrus/go.sum b/vendor/github.com/sirupsen/logrus/go.sum
deleted file mode 100644
index 596c318..0000000
--- a/vendor/github.com/sirupsen/logrus/go.sum
+++ /dev/null
@@ -1,16 +0,0 @@
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/konsorten/go-windows-terminal-sequences v0.0.0-20180402223658-b729f2633dfe h1:CHRGQ8V7OlCYtwaKPJi3iA7J+YdNKdo8j7nG5IgDhjs=
-github.com/konsorten/go-windows-terminal-sequences v0.0.0-20180402223658-b729f2633dfe/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33 h1:I6FyU15t786LL7oL/hn43zqTuEGr4PN7F4XJ1p4E3Y8=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/vendor/github.com/sirupsen/logrus/hooks.go b/vendor/github.com/sirupsen/logrus/hooks.go
deleted file mode 100644
index 3f151cd..0000000
--- a/vendor/github.com/sirupsen/logrus/hooks.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package logrus
-
-// A hook to be fired when logging on the logging levels returned from
-// `Levels()` on your implementation of the interface. Note that this is not
-// fired in a goroutine or a channel with workers, you should handle such
-// functionality yourself if your call is non-blocking and you don't wish for
-// the logging calls for levels returned from `Levels()` to block.
-type Hook interface {
-        Levels() []Level
-        Fire(*Entry) error
-}
-
-// Internal type for storing the hooks on a logger instance.
-type LevelHooks map[Level][]Hook
-
-// Add a hook to an instance of logger. This is called with
-// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
-func (hooks LevelHooks) Add(hook Hook) {
-        for _, level := range hook.Levels() {
-                hooks[level] = append(hooks[level], hook)
-        }
-}
-
-// Fire all the hooks for the passed level. Used by `entry.log` to fire
-// appropriate hooks for a log entry.
-func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
-        for _, hook := range hooks[level] {
-                if err := hook.Fire(entry); err != nil {
-                        return err
-                }
-        }
-
-        return nil
-}
diff --git a/vendor/github.com/sirupsen/logrus/json_formatter.go b/vendor/github.com/sirupsen/logrus/json_formatter.go
deleted file mode 100644
index 098a21a..0000000
--- a/vendor/github.com/sirupsen/logrus/json_formatter.go
+++ /dev/null
@@ -1,121 +0,0 @@
-package logrus
-
-import (
-        "bytes"
-        "encoding/json"
-        "fmt"
-        "runtime"
-)
-
-type fieldKey string
-
-// FieldMap allows customization of the key names for default fields.
-type FieldMap map[fieldKey]string
-
-func (f FieldMap) resolve(key fieldKey) string {
-        if k, ok := f[key]; ok {
-                return k
-        }
-
-        return string(key)
-}
-
-// JSONFormatter formats logs into parsable json
-type JSONFormatter struct {
-        // TimestampFormat sets the format used for marshaling timestamps.
-        TimestampFormat string
-
-        // DisableTimestamp allows disabling automatic timestamps in output
-        DisableTimestamp bool
-
-        // DataKey allows users to put all the log entry parameters into a nested dictionary at a given key.
-        DataKey string
-
-        // FieldMap allows users to customize the names of keys for default fields.
-        // As an example:
-        // formatter := &JSONFormatter{
-        //      FieldMap: FieldMap{
-        //               FieldKeyTime:  "@timestamp",
-        //               FieldKeyLevel: "@level",
-        //               FieldKeyMsg:   "@message",
-        //               FieldKeyFunc:  "@caller",
-        //    },
-        // }
-        FieldMap FieldMap
-
-        // CallerPrettyfier can be set by the user to modify the content
-        // of the function and file keys in the json data when ReportCaller is
-        // activated. If any of the returned value is the empty string the
-        // corresponding key will be removed from json fields.
-        CallerPrettyfier func(*runtime.Frame) (function string, file string)
-
-        // PrettyPrint will indent all json logs
-        PrettyPrint bool
-}
-
-// Format renders a single log entry
-func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
-        data := make(Fields, len(entry.Data)+4)
-        for k, v := range entry.Data {
-                switch v := v.(type) {
-                case error:
-                        // Otherwise errors are ignored by `encoding/json`
-                        // https://github.com/sirupsen/logrus/issues/137
-                        data[k] = v.Error()
-                default:
-                        data[k] = v
-                }
-        }
-
-        if f.DataKey != "" {
-                newData := make(Fields, 4)
-                newData[f.DataKey] = data
-                data = newData
-        }
-
-        prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
-
-        timestampFormat := f.TimestampFormat
-        if timestampFormat == "" {
-                timestampFormat = defaultTimestampFormat
-        }
-
-        if entry.err != "" {
-                data[f.FieldMap.resolve(FieldKeyLogrusError)] = entry.err
-        }
-        if !f.DisableTimestamp {
-                data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat)
-        }
-        data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message
-        data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()
-        if entry.HasCaller() {
-                funcVal := entry.Caller.Function
-                fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
-                if f.CallerPrettyfier != nil {
-                        funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
-                }
-                if funcVal != "" {
-                        data[f.FieldMap.resolve(FieldKeyFunc)] = funcVal
-                }
-                if fileVal != "" {
-                        data[f.FieldMap.resolve(FieldKeyFile)] = fileVal
-                }
-        }
-
-        var b *bytes.Buffer
-        if entry.Buffer != nil {
-                b = entry.Buffer
-        } else {
-                b = &bytes.Buffer{}
-        }
-
-        encoder := json.NewEncoder(b)
-        if f.PrettyPrint {
-                encoder.SetIndent("", "  ")
-        }
-        if err := encoder.Encode(data); err != nil {
-                return nil, fmt.Errorf("failed to marshal fields to JSON, %v", err)
-        }
-
-        return b.Bytes(), nil
-}
diff --git a/vendor/github.com/sirupsen/logrus/logger.go b/vendor/github.com/sirupsen/logrus/logger.go
deleted file mode 100644
index c0c0b1e..0000000
--- a/vendor/github.com/sirupsen/logrus/logger.go
+++ /dev/null
@@ -1,351 +0,0 @@
-package logrus
-
-import (
-        "context"
-        "io"
-        "os"
-        "sync"
-        "sync/atomic"
-        "time"
-)
-
-type Logger struct {
-        // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
-        // file, or leave it default which is `os.Stderr`. You can also set this to
-        // something more adventurous, such as logging to Kafka.
-        Out io.Writer
-        // Hooks for the logger instance. These allow firing events based on logging
-        // levels and log entries. For example, to send errors to an error tracking
-        // service, log to StatsD or dump the core on fatal errors.
-        Hooks LevelHooks
-        // All log entries pass through the formatter before logged to Out. The
-        // included formatters are `TextFormatter` and `JSONFormatter` for which
-        // TextFormatter is the default. In development (when a TTY is attached) it
-        // logs with colors, but to a file it wouldn't. You can easily implement your
-        // own that implements the `Formatter` interface, see the `README` or included
-        // formatters for examples.
-        Formatter Formatter
-
-        // Flag for whether to log caller info (off by default)
-        ReportCaller bool
-
-        // The logging level the logger should log at. This is typically (and defaults
-        // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
-        // logged.
-        Level Level
-        // Used to sync writing to the log. Locking is enabled by Default
-        mu MutexWrap
-        // Reusable empty entry
-        entryPool sync.Pool
-        // Function to exit the application, defaults to `os.Exit()`
-        ExitFunc exitFunc
-}
-
-type exitFunc func(int)
-
-type MutexWrap struct {
-        lock     sync.Mutex
-        disabled bool
-}
-
-func (mw *MutexWrap) Lock() {
-        if !mw.disabled {
-                mw.lock.Lock()
-        }
-}
-
-func (mw *MutexWrap) Unlock() {
-        if !mw.disabled {
-                mw.lock.Unlock()
-        }
-}
-
-func (mw *MutexWrap) Disable() {
-        mw.disabled = true
-}
-
-// Creates a new logger. Configuration should be set by changing `Formatter`,
-// `Out` and `Hooks` directly on the default logger instance. You can also just
-// instantiate your own:
-//
-//    var log = &Logger{
-//      Out: os.Stderr,
-//      Formatter: new(JSONFormatter),
-//      Hooks: make(LevelHooks),
-//      Level: logrus.DebugLevel,
-//    }
-//
-// It's recommended to make this a global instance called `log`.
-func New() *Logger {
-        return &Logger{
-                Out:          os.Stderr,
-                Formatter:    new(TextFormatter),
-                Hooks:        make(LevelHooks),
-                Level:        InfoLevel,
-                ExitFunc:     os.Exit,
-                ReportCaller: false,
-        }
-}
-
-func (logger *Logger) newEntry() *Entry {
-        entry, ok := logger.entryPool.Get().(*Entry)
-        if ok {
-                return entry
-        }
-        return NewEntry(logger)
-}
-
-func (logger *Logger) releaseEntry(entry *Entry) {
-        entry.Data = map[string]interface{}{}
-        logger.entryPool.Put(entry)
-}
-
-// Adds a field to the log entry, note that it doesn't log until you call
-// Debug, Print, Info, Warn, Error, Fatal or Panic. It only creates a log entry.
-// If you want multiple fields, use `WithFields`.
-func (logger *Logger) WithField(key string, value interface{}) *Entry {
-        entry := logger.newEntry()
-        defer logger.releaseEntry(entry)
-        return entry.WithField(key, value)
-}
-
-// Adds a struct of fields to the log entry. All it does is call `WithField` for
-// each `Field`.
-func (logger *Logger) WithFields(fields Fields) *Entry {
-        entry := logger.newEntry()
-        defer logger.releaseEntry(entry)
-        return entry.WithFields(fields)
-}
-
-// Add an error as single field to the log entry.  All it does is call
-// `WithError` for the given `error`.
-func (logger *Logger) WithError(err error) *Entry {
-        entry := logger.newEntry()
-        defer logger.releaseEntry(entry)
-        return entry.WithError(err)
-}
-
-// Add a context to the log entry.
-func (logger *Logger) WithContext(ctx context.Context) *Entry {
-        entry := logger.newEntry()
-        defer logger.releaseEntry(entry)
-        return entry.WithContext(ctx)
-}
-
-// Overrides the time of the log entry.
-func (logger *Logger) WithTime(t time.Time) *Entry {
-        entry := logger.newEntry()
-        defer logger.releaseEntry(entry)
-        return entry.WithTime(t)
-}
-
-func (logger *Logger) Logf(level Level, format string, args ...interface{}) {
-        if logger.IsLevelEnabled(level) {
-                entry := logger.newEntry()
-                entry.Logf(level, format, args...)
-                logger.releaseEntry(entry)
-        }
-}
-
-func (logger *Logger) Tracef(format string, args ...interface{}) {
-        logger.Logf(TraceLevel, format, args...)
-}
-
-func (logger *Logger) Debugf(format string, args ...interface{}) {
-        logger.Logf(DebugLevel, format, args...)
-}
-
-func (logger *Logger) Infof(format string, args ...interface{}) {
-        logger.Logf(InfoLevel, format, args...)
-}
-
-func (logger *Logger) Printf(format string, args ...interface{}) {
-        entry := logger.newEntry()
-        entry.Printf(format, args...)
-        logger.releaseEntry(entry)
-}
-
-func (logger *Logger) Warnf(format string, args ...interface{}) {
-        logger.Logf(WarnLevel, format, args...)
-}
-
-func (logger *Logger) Warningf(format string, args ...interface{}) {
-        logger.Warnf(format, args...)
-}
-
-func (logger *Logger) Errorf(format string, args ...interface{}) {
-        logger.Logf(ErrorLevel, format, args...)
-}
-
-func (logger *Logger) Fatalf(format string, args ...interface{}) {
-        logger.Logf(FatalLevel, format, args...)
-        logger.Exit(1)
-}
-
-func (logger *Logger) Panicf(format string, args ...interface{}) {
-        logger.Logf(PanicLevel, format, args...)
-}
-
-func (logger *Logger) Log(level Level, args ...interface{}) {
-        if logger.IsLevelEnabled(level) {
-                entry := logger.newEntry()
-                entry.Log(level, args...)
-                logger.releaseEntry(entry)
-        }
-}
-
-func (logger *Logger) Trace(args ...interface{}) {
-        logger.Log(TraceLevel, args...)
-}
-
-func (logger *Logger) Debug(args ...interface{}) {
-        logger.Log(DebugLevel, args...)
-}
-
-func (logger *Logger) Info(args ...interface{}) {
-        logger.Log(InfoLevel, args...)
-}
-
-func (logger *Logger) Print(args ...interface{}) {
-        entry := logger.newEntry()
-        entry.Print(args...)
-        logger.releaseEntry(entry)
-}
-
-func (logger *Logger) Warn(args ...interface{}) {
-        logger.Log(WarnLevel, args...)
-}
-
-func (logger *Logger) Warning(args ...interface{}) {
-        logger.Warn(args...)
-}
-
-func (logger *Logger) Error(args ...interface{}) {
-        logger.Log(ErrorLevel, args...)
-}
-
-func (logger *Logger) Fatal(args ...interface{}) {
-        logger.Log(FatalLevel, args...)
-        logger.Exit(1)
-}
-
-func (logger *Logger) Panic(args ...interface{}) {
-        logger.Log(PanicLevel, args...)
-}
-
-func (logger *Logger) Logln(level Level, args ...interface{}) {
-        if logger.IsLevelEnabled(level) {
-                entry := logger.newEntry()
-                entry.Logln(level, args...)
-                logger.releaseEntry(entry)
-        }
-}
-
-func (logger *Logger) Traceln(args ...interface{}) {
-        logger.Logln(TraceLevel, args...)
-}
-
-func (logger *Logger) Debugln(args ...interface{}) {
-        logger.Logln(DebugLevel, args...)
-}
-
-func (logger *Logger) Infoln(args ...interface{}) {
-        logger.Logln(InfoLevel, args...)
-}
-
-func (logger *Logger) Println(args ...interface{}) {
-        entry := logger.newEntry()
-        entry.Println(args...)
-        logger.releaseEntry(entry)
-}
-
-func (logger *Logger) Warnln(args ...interface{}) {
-        logger.Logln(WarnLevel, args...)
-}
-
-func (logger *Logger) Warningln(args ...interface{}) {
-        logger.Warnln(args...)
-}
-
-func (logger *Logger) Errorln(args ...interface{}) {
-        logger.Logln(ErrorLevel, args...)
-}
-
-func (logger *Logger) Fatalln(args ...interface{}) {
-        logger.Logln(FatalLevel, args...)
-        logger.Exit(1)
-}
-
-func (logger *Logger) Panicln(args ...interface{}) {
-        logger.Logln(PanicLevel, args...)
-}
-
-func (logger *Logger) Exit(code int) {
-        runHandlers()
-        if logger.ExitFunc == nil {
-                logger.ExitFunc = os.Exit
-        }
-        logger.ExitFunc(code)
-}
-
-//When file is opened with appending mode, it's safe to
-//write concurrently to a file (within 4k message on Linux).
-//In these cases user can choose to disable the lock.
-func (logger *Logger) SetNoLock() {
-        logger.mu.Disable()
-}
-
-func (logger *Logger) level() Level {
-        return Level(atomic.LoadUint32((*uint32)(&logger.Level)))
-}
-
-// SetLevel sets the logger level.
-func (logger *Logger) SetLevel(level Level) {
-        atomic.StoreUint32((*uint32)(&logger.Level), uint32(level))
-}
-
-// GetLevel returns the logger level.
-func (logger *Logger) GetLevel() Level {
-        return logger.level()
-}
-
-// AddHook adds a hook to the logger hooks.
-func (logger *Logger) AddHook(hook Hook) {
-        logger.mu.Lock()
-        defer logger.mu.Unlock()
-        logger.Hooks.Add(hook)
-}
-
-// IsLevelEnabled checks if the log level of the logger is greater than the level param
-func (logger *Logger) IsLevelEnabled(level Level) bool {
-        return logger.level() >= level
-}
-
-// SetFormatter sets the logger formatter.
-func (logger *Logger) SetFormatter(formatter Formatter) {
-        logger.mu.Lock()
-        defer logger.mu.Unlock()
-        logger.Formatter = formatter
-}
-
-// SetOutput sets the logger output.
-func (logger *Logger) SetOutput(output io.Writer) {
-        logger.mu.Lock()
-        defer logger.mu.Unlock()
-        logger.Out = output
-}
-
-func (logger *Logger) SetReportCaller(reportCaller bool) {
-        logger.mu.Lock()
-        defer logger.mu.Unlock()
-        logger.ReportCaller = reportCaller
-}
-
-// ReplaceHooks replaces the logger hooks and returns the old ones
-func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks {
-        logger.mu.Lock()
-        oldHooks := logger.Hooks
-        logger.Hooks = hooks
-        logger.mu.Unlock()
-        return oldHooks
-}
diff --git a/vendor/github.com/sirupsen/logrus/logrus.go b/vendor/github.com/sirupsen/logrus/logrus.go
deleted file mode 100644
index 8644761..0000000
--- a/vendor/github.com/sirupsen/logrus/logrus.go
+++ /dev/null
@@ -1,186 +0,0 @@
-package logrus
-
-import (
-        "fmt"
-        "log"
-        "strings"
-)
-
-// Fields type, used to pass to `WithFields`.
-type Fields map[string]interface{}
-
-// Level type
-type Level uint32
-
-// Convert the Level to a string. E.g. PanicLevel becomes "panic".
-func (level Level) String() string {
-        if b, err := level.MarshalText(); err == nil {
-                return string(b)
-        } else {
-                return "unknown"
-        }
-}
-
-// ParseLevel takes a string level and returns the Logrus log level constant.
-func ParseLevel(lvl string) (Level, error) {
-        switch strings.ToLower(lvl) {
-        case "panic":
-                return PanicLevel, nil
-        case "fatal":
-                return FatalLevel, nil
-        case "error":
-                return ErrorLevel, nil
-        case "warn", "warning":
-                return WarnLevel, nil
-        case "info":
-                return InfoLevel, nil
-        case "debug":
-                return DebugLevel, nil
-        case "trace":
-                return TraceLevel, nil
-        }
-
-        var l Level
-        return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
-}
-
-// UnmarshalText implements encoding.TextUnmarshaler.
-func (level *Level) UnmarshalText(text []byte) error {
-        l, err := ParseLevel(string(text))
-        if err != nil {
-                return err
-        }
-
-        *level = Level(l)
-
-        return nil
-}
-
-func (level Level) MarshalText() ([]byte, error) {
-        switch level {
-        case TraceLevel:
-                return []byte("trace"), nil
-        case DebugLevel:
-                return []byte("debug"), nil
-        case InfoLevel:
-                return []byte("info"), nil
-        case WarnLevel:
-                return []byte("warning"), nil
-        case ErrorLevel:
-                return []byte("error"), nil
-        case FatalLevel:
-                return []byte("fatal"), nil
-        case PanicLevel:
-                return []byte("panic"), nil
-        }
-
-        return nil, fmt.Errorf("not a valid logrus level %d", level)
-}
-
-// A constant exposing all logging levels
-var AllLevels = []Level{
-        PanicLevel,
-        FatalLevel,
-        ErrorLevel,
-        WarnLevel,
-        InfoLevel,
-        DebugLevel,
-        TraceLevel,
-}
-
-// These are the different logging levels. You can set the logging level to log
-// on your instance of logger, obtained with `logrus.New()`.
-const (
-        // PanicLevel level, highest level of severity. Logs and then calls panic with the
-        // message passed to Debug, Info, ...
-        PanicLevel Level = iota
-        // FatalLevel level. Logs and then calls `logger.Exit(1)`. It will exit even if the
-        // logging level is set to Panic.
-        FatalLevel
-        // ErrorLevel level. Logs. Used for errors that should definitely be noted.
-        // Commonly used for hooks to send errors to an error tracking service.
-        ErrorLevel
-        // WarnLevel level. Non-critical entries that deserve eyes.
-        WarnLevel
-        // InfoLevel level. General operational entries about what's going on inside the
-        // application.
-        InfoLevel
-        // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
-        DebugLevel
-        // TraceLevel level. Designates finer-grained informational events than the Debug.
-        TraceLevel
-)
-
-// Won't compile if StdLogger can't be realized by a log.Logger
-var (
-        _ StdLogger = &log.Logger{}
-        _ StdLogger = &Entry{}
-        _ StdLogger = &Logger{}
-)
-
-// StdLogger is what your logrus-enabled library should take, that way
-// it'll accept a stdlib logger and a logrus logger. There's no standard
-// interface, this is the closest we get, unfortunately.
-type StdLogger interface {
-        Print(...interface{})
-        Printf(string, ...interface{})
-        Println(...interface{})
-
-        Fatal(...interface{})
-        Fatalf(string, ...interface{})
-        Fatalln(...interface{})
-
-        Panic(...interface{})
-        Panicf(string, ...interface{})
-        Panicln(...interface{})
-}
-
-// The FieldLogger interface generalizes the Entry and Logger types
-type FieldLogger interface {
-        WithField(key string, value interface{}) *Entry
-        WithFields(fields Fields) *Entry
-        WithError(err error) *Entry
-
-        Debugf(format string, args ...interface{})
-        Infof(format string, args ...interface{})
-        Printf(format string, args ...interface{})
-        Warnf(format string, args ...interface{})
-        Warningf(format string, args ...interface{})
-        Errorf(format string, args ...interface{})
-        Fatalf(format string, args ...interface{})
-        Panicf(format string, args ...interface{})
-
-        Debug(args ...interface{})
-        Info(args ...interface{})
-        Print(args ...interface{})
-        Warn(args ...interface{})
-        Warning(args ...interface{})
-        Error(args ...interface{})
-        Fatal(args ...interface{})
-        Panic(args ...interface{})
-
-        Debugln(args ...interface{})
-        Infoln(args ...interface{})
-        Println(args ...interface{})
-        Warnln(args ...interface{})
-        Warningln(args ...interface{})
-        Errorln(args ...interface{})
-        Fatalln(args ...interface{})
-        Panicln(args ...interface{})
-
-        // IsDebugEnabled() bool
-        // IsInfoEnabled() bool
-        // IsWarnEnabled() bool
-        // IsErrorEnabled() bool
-        // IsFatalEnabled() bool
-        // IsPanicEnabled() bool
-}
-
-// Ext1FieldLogger (the first extension to FieldLogger) is superfluous, it is
-// here for consistancy. Do not use. Use Logger or Entry instead.
-type Ext1FieldLogger interface {
-        FieldLogger
-        Tracef(format string, args ...interface{})
-        Trace(args ...interface{})
-        Traceln(args ...interface{})
-}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go
deleted file mode 100644
index 2403de9..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// +build appengine
-
-package logrus
-
-import (
-        "io"
-)
-
-func checkIfTerminal(w io.Writer) bool {
-        return true
-}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go b/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go
deleted file mode 100644
index 3c4f43f..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// +build darwin dragonfly freebsd netbsd openbsd
-
-package logrus
-
-import "golang.org/x/sys/unix"
-
-const ioctlReadTermios = unix.TIOCGETA
-
-func isTerminal(fd int) bool {
-        _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
-        return err == nil
-}
-
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go b/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go
deleted file mode 100644
index 97af92c..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// +build js nacl plan9
-
-package logrus
-
-import (
-        "io"
-)
-
-func checkIfTerminal(w io.Writer) bool {
-        return false
-}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
deleted file mode 100644
index 3293fb3..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// +build !appengine,!js,!windows,!nacl,!plan9
-
-package logrus
-
-import (
-        "io"
-        "os"
-)
-
-func checkIfTerminal(w io.Writer) bool {
-        switch v := w.(type) {
-        case *os.File:
-                return isTerminal(int(v.Fd()))
-        default:
-                return false
-        }
-}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go b/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go
deleted file mode 100644
index f6710b3..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package logrus
-
-import (
-        "golang.org/x/sys/unix"
-)
-
-// IsTerminal returns true if the given file descriptor is a terminal.
-func isTerminal(fd int) bool {
-        _, err := unix.IoctlGetTermio(fd, unix.TCGETA)
-        return err == nil
-}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_unix.go b/vendor/github.com/sirupsen/logrus/terminal_check_unix.go
deleted file mode 100644
index 355dc96..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_unix.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// +build linux aix
-
-package logrus
-
-import "golang.org/x/sys/unix"
-
-const ioctlReadTermios = unix.TCGETS
-
-func isTerminal(fd int) bool {
-        _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
-        return err == nil
-}
-
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go b/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
deleted file mode 100644
index 572889d..0000000
--- a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// +build !appengine,!js,windows
-
-package logrus
-
-import (
-        "io"
-        "os"
-        "syscall"
-
-        sequences "github.com/konsorten/go-windows-terminal-sequences"
-)
-
-func initTerminal(w io.Writer) {
-        switch v := w.(type) {
-        case *os.File:
-                sequences.EnableVirtualTerminalProcessing(syscall.Handle(v.Fd()), true)
-        }
-}
-
-func checkIfTerminal(w io.Writer) bool {
-        var ret bool
-        switch v := w.(type) {
-        case *os.File:
-                var mode uint32
-                err := syscall.GetConsoleMode(syscall.Handle(v.Fd()), &mode)
-                ret = (err == nil)
-        default:
-                ret = false
-        }
-        if ret {
-                initTerminal(w)
-        }
-        return ret
-}
diff --git a/vendor/github.com/sirupsen/logrus/text_formatter.go b/vendor/github.com/sirupsen/logrus/text_formatter.go
deleted file mode 100644
index e01587c..0000000
--- a/vendor/github.com/sirupsen/logrus/text_formatter.go
+++ /dev/null
@@ -1,295 +0,0 @@
-package logrus
-
-import (
-        "bytes"
-        "fmt"
-        "os"
-        "runtime"
-        "sort"
-        "strings"
-        "sync"
-        "time"
-)
-
-const (
-        red    = 31
-        yellow = 33
-        blue   = 36
-        gray   = 37
-)
-
-var baseTimestamp time.Time
-
-func init() {
-        baseTimestamp = time.Now()
-}
-
-// TextFormatter formats logs into text
-type TextFormatter struct {
-        // Set to true to bypass checking for a TTY before outputting colors.
-        ForceColors bool
-
-        // Force disabling colors.
-        DisableColors bool
-
-        // Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
-        EnvironmentOverrideColors bool
-
-        // Disable timestamp logging. useful when output is redirected to logging
-        // system that already adds timestamps.
-        DisableTimestamp bool
-
-        // Enable logging the full timestamp when a TTY is attached instead of just
-        // the time passed since beginning of execution.
-        FullTimestamp bool
-
-        // TimestampFormat to use for display when a full timestamp is printed
-        TimestampFormat string
-
-        // The fields are sorted by default for a consistent output. For applications
-        // that log extremely frequently and don't use the JSON formatter this may not
-        // be desired.
-        DisableSorting bool
-
-        // The keys sorting function, when uninitialized it uses sort.Strings.
-        SortingFunc func([]string)
-
-        // Disables the truncation of the level text to 4 characters.
-        DisableLevelTruncation bool
-
-        // QuoteEmptyFields will wrap empty fields in quotes if true
-        QuoteEmptyFields bool
-
-        // Whether the logger's out is to a terminal
-        isTerminal bool
-
-        // FieldMap allows users to customize the names of keys for default fields.
-        // As an example:
-        // formatter := &TextFormatter{
-        //     FieldMap: FieldMap{
-        //         FieldKeyTime:  "@timestamp",
-        //         FieldKeyLevel: "@level",
-        //         FieldKeyMsg:   "@message"}}
-        FieldMap FieldMap
-
-        // CallerPrettyfier can be set by the user to modify the content
-        // of the function and file keys in the data when ReportCaller is
-        // activated. If any of the returned value is the empty string the
-        // corresponding key will be removed from fields.
-        CallerPrettyfier func(*runtime.Frame) (function string, file string)
-
-        terminalInitOnce sync.Once
-}
-
-func (f *TextFormatter) init(entry *Entry) {
-        if entry.Logger != nil {
-                f.isTerminal = checkIfTerminal(entry.Logger.Out)
-        }
-}
-
-func (f *TextFormatter) isColored() bool {
-        isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows"))
-
-        if f.EnvironmentOverrideColors {
-                if force, ok := os.LookupEnv("CLICOLOR_FORCE"); ok && force != "0" {
-                        isColored = true
-                } else if ok && force == "0" {
-                        isColored = false
-                } else if os.Getenv("CLICOLOR") == "0" {
-                        isColored = false
-                }
-        }
-
-        return isColored && !f.DisableColors
-}
-
-// Format renders a single log entry
-func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
-        data := make(Fields)
-        for k, v := range entry.Data {
-                data[k] = v
-        }
-        prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
-        keys := make([]string, 0, len(data))
-        for k := range data {
-                keys = append(keys, k)
-        }
-
-        var funcVal, fileVal string
-
-        fixedKeys := make([]string, 0, 4+len(data))
-        if !f.DisableTimestamp {
-                fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
-        }
-        fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel))
-        if entry.Message != "" {
-                fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg))
-        }
-        if entry.err != "" {
-                fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))
-        }
-        if entry.HasCaller() {
-                if f.CallerPrettyfier != nil {
-                        funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
-                } else {
-                        funcVal = entry.Caller.Function
-                        fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
-                }
-
-                if funcVal != "" {
-                        fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))
-                }
-                if fileVal != "" {
-                        fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))
-                }
-        }
-
-        if !f.DisableSorting {
-                if f.SortingFunc == nil {
-                        sort.Strings(keys)
-                        fixedKeys = append(fixedKeys, keys...)
-                } else {
-                        if !f.isColored() {
-                                fixedKeys = append(fixedKeys, keys...)
-                                f.SortingFunc(fixedKeys)
-                        } else {
-                                f.SortingFunc(keys)
-                        }
-                }
-        } else {
-                fixedKeys = append(fixedKeys, keys...)
-        }
-
-        var b *bytes.Buffer
-        if entry.Buffer != nil {
-                b = entry.Buffer
-        } else {
-                b = &bytes.Buffer{}
-        }
-
-        f.terminalInitOnce.Do(func() { f.init(entry) })
-
-        timestampFormat := f.TimestampFormat
-        if timestampFormat == "" {
-                timestampFormat = defaultTimestampFormat
-        }
-        if f.isColored() {
-                f.printColored(b, entry, keys, data, timestampFormat)
-        } else {
-
-                for _, key := range fixedKeys {
-                        var value interface{}
-                        switch {
-                        case key == f.FieldMap.resolve(FieldKeyTime):
-                                value = entry.Time.Format(timestampFormat)
-                        case key == f.FieldMap.resolve(FieldKeyLevel):
-                                value = entry.Level.String()
-                        case key == f.FieldMap.resolve(FieldKeyMsg):
-                                value = entry.Message
-                        case key == f.FieldMap.resolve(FieldKeyLogrusError):
-                                value = entry.err
-                        case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():
-                                value = funcVal
-                        case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():
-                                value = fileVal
-                        default:
-                                value = data[key]
-                        }
-                        f.appendKeyValue(b, key, value)
-                }
-        }
-
-        b.WriteByte('\n')
-        return b.Bytes(), nil
-}
-
-func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) {
-        var levelColor int
-        switch entry.Level {
-        case DebugLevel, TraceLevel:
-                levelColor = gray
-        case WarnLevel:
-                levelColor = yellow
-        case ErrorLevel, FatalLevel, PanicLevel:
-                levelColor = red
-        default:
-                levelColor = blue
-        }
-
-        levelText := strings.ToUpper(entry.Level.String())
-        if !f.DisableLevelTruncation {
-                levelText = levelText[0:4]
-        }
-
-        // Remove a single newline if it already exists in the message to keep
-        // the behavior of logrus text_formatter the same as the stdlib log package
-        entry.Message = strings.TrimSuffix(entry.Message, "\n")
-
-        caller := ""
-        if entry.HasCaller() {
-                funcVal := fmt.Sprintf("%s()", entry.Caller.Function)
-                fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
-
-                if f.CallerPrettyfier != nil {
-                        funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
-                }
-
-                if fileVal == "" {
-                        caller = funcVal
-                } else if funcVal == "" {
-                        caller = fileVal
-                } else {
-                        caller = fileVal + " " + funcVal
-                }
-        }
-
-        if f.DisableTimestamp {
-                fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message)
-        } else if !f.FullTimestamp {
-                fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message)
-        } else {
-                fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message)
-        }
-        for _, k := range keys {
-                v := data[k]
-                fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
-                f.appendValue(b, v)
-        }
-}
-
-func (f *TextFormatter) needsQuoting(text string) bool {
-        if f.QuoteEmptyFields && len(text) == 0 {
-                return true
-        }
-        for _, ch := range text {
-                if !((ch >= 'a' && ch <= 'z') ||
-                        (ch >= 'A' && ch <= 'Z') ||
-                        (ch >= '0' && ch <= '9') ||
-                        ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') {
-                        return true
-                }
-        }
-        return false
-}
-
-func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
-        if b.Len() > 0 {
-                b.WriteByte(' ')
-        }
-        b.WriteString(key)
-        b.WriteByte('=')
-        f.appendValue(b, value)
-}
-
-func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
-        stringVal, ok := value.(string)
-        if !ok {
-                stringVal = fmt.Sprint(value)
-        }
-
-        if !f.needsQuoting(stringVal) {
-                b.WriteString(stringVal)
-        } else {
-                b.WriteString(fmt.Sprintf("%q", stringVal))
-        }
-}
diff --git a/vendor/github.com/sirupsen/logrus/writer.go b/vendor/github.com/sirupsen/logrus/writer.go
deleted file mode 100644
index 9e1f751..0000000
--- a/vendor/github.com/sirupsen/logrus/writer.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package logrus
-
-import (
-        "bufio"
-        "io"
-        "runtime"
-)
-
-func (logger *Logger) Writer() *io.PipeWriter {
-        return logger.WriterLevel(InfoLevel)
-}
-
-func (logger *Logger) WriterLevel(level Level) *io.PipeWriter {
-        return NewEntry(logger).WriterLevel(level)
-}
-
-func (entry *Entry) Writer() *io.PipeWriter {
-        return entry.WriterLevel(InfoLevel)
-}
-
-func (entry *Entry) WriterLevel(level Level) *io.PipeWriter {
-        reader, writer := io.Pipe()
-
-        var printFunc func(args ...interface{})
-
-        switch level {
-        case TraceLevel:
-                printFunc = entry.Trace
-        case DebugLevel:
-                printFunc = entry.Debug
-        case InfoLevel:
-                printFunc = entry.Info
-        case WarnLevel:
-                printFunc = entry.Warn
-        case ErrorLevel:
-                printFunc = entry.Error
-        case FatalLevel:
-                printFunc = entry.Fatal
-        case PanicLevel:
-                printFunc = entry.Panic
-        default:
-                printFunc = entry.Print
-        }
-
-        go entry.writerScanner(reader, printFunc)
-        runtime.SetFinalizer(writer, writerFinalizer)
-
-        return writer
-}
-
-func (entry *Entry) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) {
-        scanner := bufio.NewScanner(reader)
-        for scanner.Scan() {
-                printFunc(scanner.Text())
-        }
-        if err := scanner.Err(); err != nil {
-                entry.Errorf("Error while reading from Writer: %s", err)
-        }
-        reader.Close()
-}
-
-func writerFinalizer(writer *io.PipeWriter) {
-        writer.Close()
-}
diff --git a/vendor/golang.org/x/sys/windows/registry/key.go b/vendor/golang.org/x/sys/windows/registry/key.go
deleted file mode 100644
index c256483..0000000
--- a/vendor/golang.org/x/sys/windows/registry/key.go
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright 2015 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.
-
-// +build windows
-
-// Package registry provides access to the Windows registry.
-//
-// Here is a simple example, opening a registry key and reading a string value from it.
-//
-//      k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
-//      if err != nil {
-//              log.Fatal(err)
-//      }
-//      defer k.Close()
-//
-//      s, _, err := k.GetStringValue("SystemRoot")
-//      if err != nil {
-//              log.Fatal(err)
-//      }
-//      fmt.Printf("Windows system root is %q\n", s)
-//
-package registry
-
-import (
-        "io"
-        "syscall"
-        "time"
-)
-
-const (
-        // Registry key security and access rights.
-        // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724878.aspx
-        // for details.
-        ALL_ACCESS         = 0xf003f
-        CREATE_LINK        = 0x00020
-        CREATE_SUB_KEY     = 0x00004
-        ENUMERATE_SUB_KEYS = 0x00008
-        EXECUTE            = 0x20019
-        NOTIFY             = 0x00010
-        QUERY_VALUE        = 0x00001
-        READ               = 0x20019
-        SET_VALUE          = 0x00002
-        WOW64_32KEY        = 0x00200
-        WOW64_64KEY        = 0x00100
-        WRITE              = 0x20006
-)
-
-// Key is a handle to an open Windows registry key.
-// Keys can be obtained by calling OpenKey; there are
-// also some predefined root keys such as CURRENT_USER.
-// Keys can be used directly in the Windows API.
-type Key syscall.Handle
-
-const (
-        // Windows defines some predefined root keys that are always open.
-        // An application can use these keys as entry points to the registry.
-        // Normally these keys are used in OpenKey to open new keys,
-        // but they can also be used anywhere a Key is required.
-        CLASSES_ROOT     = Key(syscall.HKEY_CLASSES_ROOT)
-        CURRENT_USER     = Key(syscall.HKEY_CURRENT_USER)
-        LOCAL_MACHINE    = Key(syscall.HKEY_LOCAL_MACHINE)
-        USERS            = Key(syscall.HKEY_USERS)
-        CURRENT_CONFIG   = Key(syscall.HKEY_CURRENT_CONFIG)
-        PERFORMANCE_DATA = Key(syscall.HKEY_PERFORMANCE_DATA)
-)
-
-// Close closes open key k.
-func (k Key) Close() error {
-        return syscall.RegCloseKey(syscall.Handle(k))
-}
-
-// OpenKey opens a new key with path name relative to key k.
-// It accepts any open key, including CURRENT_USER and others,
-// and returns the new key and an error.
-// The access parameter specifies desired access rights to the
-// key to be opened.
-func OpenKey(k Key, path string, access uint32) (Key, error) {
-        p, err := syscall.UTF16PtrFromString(path)
-        if err != nil {
-                return 0, err
-        }
-        var subkey syscall.Handle
-        err = syscall.RegOpenKeyEx(syscall.Handle(k), p, 0, access, &subkey)
-        if err != nil {
-                return 0, err
-        }
-        return Key(subkey), nil
-}
-
-// OpenRemoteKey opens a predefined registry key on another
-// computer pcname. The key to be opened is specified by k, but
-// can only be one of LOCAL_MACHINE, PERFORMANCE_DATA or USERS.
-// If pcname is "", OpenRemoteKey returns local computer key.
-func OpenRemoteKey(pcname string, k Key) (Key, error) {
-        var err error
-        var p *uint16
-        if pcname != "" {
-                p, err = syscall.UTF16PtrFromString(`\\` + pcname)
-                if err != nil {
-                        return 0, err
-                }
-        }
-        var remoteKey syscall.Handle
-        err = regConnectRegistry(p, syscall.Handle(k), &remoteKey)
-        if err != nil {
-                return 0, err
-        }
-        return Key(remoteKey), nil
-}
-
-// ReadSubKeyNames returns the names of subkeys of key k.
-// The parameter n controls the number of returned names,
-// analogous to the way os.File.Readdirnames works.
-func (k Key) ReadSubKeyNames(n int) ([]string, error) {
-        names := make([]string, 0)
-        // Registry key size limit is 255 bytes and described there:
-        // https://msdn.microsoft.com/library/windows/desktop/ms724872.aspx
-        buf := make([]uint16, 256) //plus extra room for terminating zero byte
-loopItems:
-        for i := uint32(0); ; i++ {
-                if n > 0 {
-                        if len(names) == n {
-                                return names, nil
-                        }
-                }
-                l := uint32(len(buf))
-                for {
-                        err := syscall.RegEnumKeyEx(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
-                        if err == nil {
-                                break
-                        }
-                        if err == syscall.ERROR_MORE_DATA {
-                                // Double buffer size and try again.
-                                l = uint32(2 * len(buf))
-                                buf = make([]uint16, l)
-                                continue
-                        }
-                        if err == _ERROR_NO_MORE_ITEMS {
-                                break loopItems
-                        }
-                        return names, err
-                }
-                names = append(names, syscall.UTF16ToString(buf[:l]))
-        }
-        if n > len(names) {
-                return names, io.EOF
-        }
-        return names, nil
-}
-
-// CreateKey creates a key named path under open key k.
-// CreateKey returns the new key and a boolean flag that reports
-// whether the key already existed.
-// The access parameter specifies the access rights for the key
-// to be created.
-func CreateKey(k Key, path string, access uint32) (newk Key, openedExisting bool, err error) {
-        var h syscall.Handle
-        var d uint32
-        err = regCreateKeyEx(syscall.Handle(k), syscall.StringToUTF16Ptr(path),
-                0, nil, _REG_OPTION_NON_VOLATILE, access, nil, &h, &d)
-        if err != nil {
-                return 0, false, err
-        }
-        return Key(h), d == _REG_OPENED_EXISTING_KEY, nil
-}
-
-// DeleteKey deletes the subkey path of key k and its values.
-func DeleteKey(k Key, path string) error {
-        return regDeleteKey(syscall.Handle(k), syscall.StringToUTF16Ptr(path))
-}
-
-// A KeyInfo describes the statistics of a key. It is returned by Stat.
-type KeyInfo struct {
-        SubKeyCount     uint32
-        MaxSubKeyLen    uint32 // size of the key's subkey with the longest name, in Unicode characters, not including the terminating zero byte
-        ValueCount      uint32
-        MaxValueNameLen uint32 // size of the key's longest value name, in Unicode characters, not including the terminating zero byte
-        MaxValueLen     uint32 // longest data component among the key's values, in bytes
-        lastWriteTime   syscall.Filetime
-}
-
-// ModTime returns the key's last write time.
-func (ki *KeyInfo) ModTime() time.Time {
-        return time.Unix(0, ki.lastWriteTime.Nanoseconds())
-}
-
-// Stat retrieves information about the open key k.
-func (k Key) Stat() (*KeyInfo, error) {
-        var ki KeyInfo
-        err := syscall.RegQueryInfoKey(syscall.Handle(k), nil, nil, nil,
-                &ki.SubKeyCount, &ki.MaxSubKeyLen, nil, &ki.ValueCount,
-                &ki.MaxValueNameLen, &ki.MaxValueLen, nil, &ki.lastWriteTime)
-        if err != nil {
-                return nil, err
-        }
-        return &ki, nil
-}
diff --git a/vendor/golang.org/x/sys/windows/registry/mksyscall.go b/vendor/golang.org/x/sys/windows/registry/mksyscall.go
deleted file mode 100644
index cf843ce..0000000
--- a/vendor/golang.org/x/sys/windows/registry/mksyscall.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2015 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.
-
-// +build generate
-
-package registry
-
-//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall.go
diff --git a/vendor/golang.org/x/sys/windows/registry/syscall.go b/vendor/golang.org/x/sys/windows/registry/syscall.go
deleted file mode 100644
index e66643c..0000000
--- a/vendor/golang.org/x/sys/windows/registry/syscall.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2015 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.
-
-// +build windows
-
-package registry
-
-import "syscall"
-
-const (
-        _REG_OPTION_NON_VOLATILE = 0
-
-        _REG_CREATED_NEW_KEY     = 1
-        _REG_OPENED_EXISTING_KEY = 2
-
-        _ERROR_NO_MORE_ITEMS syscall.Errno = 259
-)
-
-func LoadRegLoadMUIString() error {
-        return procRegLoadMUIStringW.Find()
-}
-
-//sys   regCreateKeyEx(key syscall.Handle, subkey *uint16, reserved uint32, class *uint16, options uint32, desired uint32, sa *syscall.SecurityAttributes, result *syscall.Handle, disposition *uint32) (regerrno error) = advapi32.RegCreateKeyExW
-//sys   regDeleteKey(key syscall.Handle, subkey *uint16) (regerrno error) = advapi32.RegDeleteKeyW
-//sys   regSetValueEx(key syscall.Handle, valueName *uint16, reserved uint32, vtype uint32, buf *byte, bufsize uint32) (regerrno error) = advapi32.RegSetValueExW
-//sys   regEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegEnumValueW
-//sys   regDeleteValue(key syscall.Handle, name *uint16) (regerrno error) = advapi32.RegDeleteValueW
-//sys   regLoadMUIString(key syscall.Handle, name *uint16, buf *uint16, buflen uint32, buflenCopied *uint32, flags uint32, dir *uint16) (regerrno error) = advapi32.RegLoadMUIStringW
-//sys   regConnectRegistry(machinename *uint16, key syscall.Handle, result *syscall.Handle) (regerrno error) = advapi32.RegConnectRegistryW
-
-//sys   expandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) = kernel32.ExpandEnvironmentStringsW
diff --git a/vendor/golang.org/x/sys/windows/registry/value.go b/vendor/golang.org/x/sys/windows/registry/value.go
deleted file mode 100644
index 7487e05..0000000
--- a/vendor/golang.org/x/sys/windows/registry/value.go
+++ /dev/null
@@ -1,387 +0,0 @@
-// Copyright 2015 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.
-
-// +build windows
-
-package registry
-
-import (
-        "errors"
-        "io"
-        "syscall"
-        "unicode/utf16"
-        "unsafe"
-)
-
-const (
-        // Registry value types.
-        NONE                       = 0
-        SZ                         = 1
-        EXPAND_SZ                  = 2
-        BINARY                     = 3
-        DWORD                      = 4
-        DWORD_BIG_ENDIAN           = 5
-        LINK                       = 6
-        MULTI_SZ                   = 7
-        RESOURCE_LIST              = 8
-        FULL_RESOURCE_DESCRIPTOR   = 9
-        RESOURCE_REQUIREMENTS_LIST = 10
-        QWORD                      = 11
-)
-
-var (
-        // ErrShortBuffer is returned when the buffer was too short for the operation.
-        ErrShortBuffer = syscall.ERROR_MORE_DATA
-
-        // ErrNotExist is returned when a registry key or value does not exist.
-        ErrNotExist = syscall.ERROR_FILE_NOT_FOUND
-
-        // ErrUnexpectedType is returned by Get*Value when the value's type was unexpected.
-        ErrUnexpectedType = errors.New("unexpected key value type")
-)
-
-// GetValue retrieves the type and data for the specified value associated
-// with an open key k. It fills up buffer buf and returns the retrieved
-// byte count n. If buf is too small to fit the stored value it returns
-// ErrShortBuffer error along with the required buffer size n.
-// If no buffer is provided, it returns true and actual buffer size n.
-// If no buffer is provided, GetValue returns the value's type only.
-// If the value does not exist, the error returned is ErrNotExist.
-//
-// GetValue is a low level function. If value's type is known, use the appropriate
-// Get*Value function instead.
-func (k Key) GetValue(name string, buf []byte) (n int, valtype uint32, err error) {
-        pname, err := syscall.UTF16PtrFromString(name)
-        if err != nil {
-                return 0, 0, err
-        }
-        var pbuf *byte
-        if len(buf) > 0 {
-                pbuf = (*byte)(unsafe.Pointer(&buf[0]))
-        }
-        l := uint32(len(buf))
-        err = syscall.RegQueryValueEx(syscall.Handle(k), pname, nil, &valtype, pbuf, &l)
-        if err != nil {
-                return int(l), valtype, err
-        }
-        return int(l), valtype, nil
-}
-
-func (k Key) getValue(name string, buf []byte) (data []byte, valtype uint32, err error) {
-        p, err := syscall.UTF16PtrFromString(name)
-        if err != nil {
-                return nil, 0, err
-        }
-        var t uint32
-        n := uint32(len(buf))
-        for {
-                err = syscall.RegQueryValueEx(syscall.Handle(k), p, nil, &t, (*byte)(unsafe.Pointer(&buf[0])), &n)
-                if err == nil {
-                        return buf[:n], t, nil
-                }
-                if err != syscall.ERROR_MORE_DATA {
-                        return nil, 0, err
-                }
-                if n <= uint32(len(buf)) {
-                        return nil, 0, err
-                }
-                buf = make([]byte, n)
-        }
-}
-
-// GetStringValue retrieves the string value for the specified
-// value name associated with an open key k. It also returns the value's type.
-// If value does not exist, GetStringValue returns ErrNotExist.
-// If value is not SZ or EXPAND_SZ, it will return the correct value
-// type and ErrUnexpectedType.
-func (k Key) GetStringValue(name string) (val string, valtype uint32, err error) {
-        data, typ, err2 := k.getValue(name, make([]byte, 64))
-        if err2 != nil {
-                return "", typ, err2
-        }
-        switch typ {
-        case SZ, EXPAND_SZ:
-        default:
-                return "", typ, ErrUnexpectedType
-        }
-        if len(data) == 0 {
-                return "", typ, nil
-        }
-        u := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[:]
-        return syscall.UTF16ToString(u), typ, nil
-}
-
-// GetMUIStringValue retrieves the localized string value for
-// the specified value name associated with an open key k.
-// If the value name doesn't exist or the localized string value
-// can't be resolved, GetMUIStringValue returns ErrNotExist.
-// GetMUIStringValue panics if the system doesn't support
-// regLoadMUIString; use LoadRegLoadMUIString to check if
-// regLoadMUIString is supported before calling this function.
-func (k Key) GetMUIStringValue(name string) (string, error) {
-        pname, err := syscall.UTF16PtrFromString(name)
-        if err != nil {
-                return "", err
-        }
-
-        buf := make([]uint16, 1024)
-        var buflen uint32
-        var pdir *uint16
-
-        err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
-        if err == syscall.ERROR_FILE_NOT_FOUND { // Try fallback path
-
-                // Try to resolve the string value using the system directory as
-                // a DLL search path; this assumes the string value is of the form
-                // @[path]\dllname,-strID but with no path given, e.g. @tzres.dll,-320.
-
-                // This approach works with tzres.dll but may have to be revised
-                // in the future to allow callers to provide custom search paths.
-
-                var s string
-                s, err = ExpandString("%SystemRoot%\\system32\\")
-                if err != nil {
-                        return "", err
-                }
-                pdir, err = syscall.UTF16PtrFromString(s)
-                if err != nil {
-                        return "", err
-                }
-
-                err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
-        }
-
-        for err == syscall.ERROR_MORE_DATA { // Grow buffer if needed
-                if buflen <= uint32(len(buf)) {
-                        break // Buffer not growing, assume race; break
-                }
-                buf = make([]uint16, buflen)
-                err = regLoadMUIString(syscall.Handle(k), pname, &buf[0], uint32(len(buf)), &buflen, 0, pdir)
-        }
-
-        if err != nil {
-                return "", err
-        }
-
-        return syscall.UTF16ToString(buf), nil
-}
-
-// ExpandString expands environment-variable strings and replaces
-// them with the values defined for the current user.
-// Use ExpandString to expand EXPAND_SZ strings.
-func ExpandString(value string) (string, error) {
-        if value == "" {
-                return "", nil
-        }
-        p, err := syscall.UTF16PtrFromString(value)
-        if err != nil {
-                return "", err
-        }
-        r := make([]uint16, 100)
-        for {
-                n, err := expandEnvironmentStrings(p, &r[0], uint32(len(r)))
-                if err != nil {
-                        return "", err
-                }
-                if n <= uint32(len(r)) {
-                        u := (*[1 << 29]uint16)(unsafe.Pointer(&r[0]))[:]
-                        return syscall.UTF16ToString(u), nil
-                }
-                r = make([]uint16, n)
-        }
-}
-
-// GetStringsValue retrieves the []string value for the specified
-// value name associated with an open key k. It also returns the value's type.
-// If value does not exist, GetStringsValue returns ErrNotExist.
-// If value is not MULTI_SZ, it will return the correct value
-// type and ErrUnexpectedType.
-func (k Key) GetStringsValue(name string) (val []string, valtype uint32, err error) {
-        data, typ, err2 := k.getValue(name, make([]byte, 64))
-        if err2 != nil {
-                return nil, typ, err2
-        }
-        if typ != MULTI_SZ {
-                return nil, typ, ErrUnexpectedType
-        }
-        if len(data) == 0 {
-                return nil, typ, nil
-        }
-        p := (*[1 << 29]uint16)(unsafe.Pointer(&data[0]))[:len(data)/2]
-        if len(p) == 0 {
-                return nil, typ, nil
-        }
-        if p[len(p)-1] == 0 {
-                p = p[:len(p)-1] // remove terminating null
-        }
-        val = make([]string, 0, 5)
-        from := 0
-        for i, c := range p {
-                if c == 0 {
-                        val = append(val, string(utf16.Decode(p[from:i])))
-                        from = i + 1
-                }
-        }
-        return val, typ, nil
-}
-
-// GetIntegerValue retrieves the integer value for the specified
-// value name associated with an open key k. It also returns the value's type.
-// If value does not exist, GetIntegerValue returns ErrNotExist.
-// If value is not DWORD or QWORD, it will return the correct value
-// type and ErrUnexpectedType.
-func (k Key) GetIntegerValue(name string) (val uint64, valtype uint32, err error) {
-        data, typ, err2 := k.getValue(name, make([]byte, 8))
-        if err2 != nil {
-                return 0, typ, err2
-        }
-        switch typ {
-        case DWORD:
-                if len(data) != 4 {
-                        return 0, typ, errors.New("DWORD value is not 4 bytes long")
-                }
-                var val32 uint32
-                copy((*[4]byte)(unsafe.Pointer(&val32))[:], data)
-                return uint64(val32), DWORD, nil
-        case QWORD:
-                if len(data) != 8 {
-                        return 0, typ, errors.New("QWORD value is not 8 bytes long")
-                }
-                copy((*[8]byte)(unsafe.Pointer(&val))[:], data)
-                return val, QWORD, nil
-        default:
-                return 0, typ, ErrUnexpectedType
-        }
-}
-
-// GetBinaryValue retrieves the binary value for the specified
-// value name associated with an open key k. It also returns the value's type.
-// If value does not exist, GetBinaryValue returns ErrNotExist.
-// If value is not BINARY, it will return the correct value
-// type and ErrUnexpectedType.
-func (k Key) GetBinaryValue(name string) (val []byte, valtype uint32, err error) {
-        data, typ, err2 := k.getValue(name, make([]byte, 64))
-        if err2 != nil {
-                return nil, typ, err2
-        }
-        if typ != BINARY {
-                return nil, typ, ErrUnexpectedType
-        }
-        return data, typ, nil
-}
-
-func (k Key) setValue(name string, valtype uint32, data []byte) error {
-        p, err := syscall.UTF16PtrFromString(name)
-        if err != nil {
-                return err
-        }
-        if len(data) == 0 {
-                return regSetValueEx(syscall.Handle(k), p, 0, valtype, nil, 0)
-        }
-        return regSetValueEx(syscall.Handle(k), p, 0, valtype, &data[0], uint32(len(data)))
-}
-
-// SetDWordValue sets the data and type of a name value
-// under key k to value and DWORD.
-func (k Key) SetDWordValue(name string, value uint32) error {
-        return k.setValue(name, DWORD, (*[4]byte)(unsafe.Pointer(&value))[:])
-}
-
-// SetQWordValue sets the data and type of a name value
-// under key k to value and QWORD.
-func (k Key) SetQWordValue(name string, value uint64) error {
-        return k.setValue(name, QWORD, (*[8]byte)(unsafe.Pointer(&value))[:])
-}
-
-func (k Key) setStringValue(name string, valtype uint32, value string) error {
-        v, err := syscall.UTF16FromString(value)
-        if err != nil {
-                return err
-        }
-        buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[:len(v)*2]
-        return k.setValue(name, valtype, buf)
-}
-
-// SetStringValue sets the data and type of a name value
-// under key k to value and SZ. The value must not contain a zero byte.
-func (k Key) SetStringValue(name, value string) error {
-        return k.setStringValue(name, SZ, value)
-}
-
-// SetExpandStringValue sets the data and type of a name value
-// under key k to value and EXPAND_SZ. The value must not contain a zero byte.
-func (k Key) SetExpandStringValue(name, value string) error {
-        return k.setStringValue(name, EXPAND_SZ, value)
-}
-
-// SetStringsValue sets the data and type of a name value
-// under key k to value and MULTI_SZ. The value strings
-// must not contain a zero byte.
-func (k Key) SetStringsValue(name string, value []string) error {
-        ss := ""
-        for _, s := range value {
-                for i := 0; i < len(s); i++ {
-                        if s[i] == 0 {
-                                return errors.New("string cannot have 0 inside")
-                        }
-                }
-                ss += s + "\x00"
-        }
-        v := utf16.Encode([]rune(ss + "\x00"))
-        buf := (*[1 << 29]byte)(unsafe.Pointer(&v[0]))[:len(v)*2]
-        return k.setValue(name, MULTI_SZ, buf)
-}
-
-// SetBinaryValue sets the data and type of a name value
-// under key k to value and BINARY.
-func (k Key) SetBinaryValue(name string, value []byte) error {
-        return k.setValue(name, BINARY, value)
-}
-
-// DeleteValue removes a named value from the key k.
-func (k Key) DeleteValue(name string) error {
-        return regDeleteValue(syscall.Handle(k), syscall.StringToUTF16Ptr(name))
-}
-
-// ReadValueNames returns the value names of key k.
-// The parameter n controls the number of returned names,
-// analogous to the way os.File.Readdirnames works.
-func (k Key) ReadValueNames(n int) ([]string, error) {
-        ki, err := k.Stat()
-        if err != nil {
-                return nil, err
-        }
-        names := make([]string, 0, ki.ValueCount)
-        buf := make([]uint16, ki.MaxValueNameLen+1) // extra room for terminating null character
-loopItems:
-        for i := uint32(0); ; i++ {
-                if n > 0 {
-                        if len(names) == n {
-                                return names, nil
-                        }
-                }
-                l := uint32(len(buf))
-                for {
-                        err := regEnumValue(syscall.Handle(k), i, &buf[0], &l, nil, nil, nil, nil)
-                        if err == nil {
-                                break
-                        }
-                        if err == syscall.ERROR_MORE_DATA {
-                                // Double buffer size and try again.
-                                l = uint32(2 * len(buf))
-                                buf = make([]uint16, l)
-                                continue
-                        }
-                        if err == _ERROR_NO_MORE_ITEMS {
-                                break loopItems
-                        }
-                        return names, err
-                }
-                names = append(names, syscall.UTF16ToString(buf[:l]))
-        }
-        if n > len(names) {
-                return names, io.EOF
-        }
-        return names, nil
-}
diff --git a/vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go
deleted file mode 100644
index 3778075..0000000
--- a/vendor/golang.org/x/sys/windows/registry/zsyscall_windows.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Code generated by 'go generate'; DO NOT EDIT.
-
-package registry
-
-import (
-        "syscall"
-        "unsafe"
-
-        "golang.org/x/sys/windows"
-)
-
-var _ unsafe.Pointer
-
-// Do the interface allocations only once for common
-// Errno values.
-const (
-        errnoERROR_IO_PENDING = 997
-)
-
-var (
-        errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
-)
-
-// errnoErr returns common boxed Errno values, to prevent
-// allocations at runtime.
-func errnoErr(e syscall.Errno) error {
-        switch e {
-        case 0:
-                return nil
-        case errnoERROR_IO_PENDING:
-                return errERROR_IO_PENDING
-        }
-        // TODO: add more here, after collecting data on the common
-        // error values see on Windows. (perhaps when running
-        // all.bat?)
-        return e
-}
-
-var (
-        modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
-        modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
-
-        procRegCreateKeyExW           = modadvapi32.NewProc("RegCreateKeyExW")
-        procRegDeleteKeyW             = modadvapi32.NewProc("RegDeleteKeyW")
-        procRegSetValueExW            = modadvapi32.NewProc("RegSetValueExW")
-        procRegEnumValueW             = modadvapi32.NewProc("RegEnumValueW")
-        procRegDeleteValueW           = modadvapi32.NewProc("RegDeleteValueW")
-        procRegLoadMUIStringW         = modadvapi32.NewProc("RegLoadMUIStringW")
-        procRegConnectRegistryW       = modadvapi32.NewProc("RegConnectRegistryW")
-        procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW")
-)
-
-func regCreateKeyEx(key syscall.Handle, subkey *uint16, reserved uint32, class *uint16, options uint32, desired uint32, sa *syscall.SecurityAttributes, result *syscall.Handle, disposition *uint32) (regerrno error) {
-        r0, _, _ := syscall.Syscall9(procRegCreateKeyExW.Addr(), 9, uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(reserved), uintptr(unsafe.Pointer(class)), uintptr(options), uintptr(desired), uintptr(unsafe.Pointer(sa)), uintptr(unsafe.Pointer(result)), uintptr(unsafe.Pointer(disposition)))
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func regDeleteKey(key syscall.Handle, subkey *uint16) (regerrno error) {
-        r0, _, _ := syscall.Syscall(procRegDeleteKeyW.Addr(), 2, uintptr(key), uintptr(unsafe.Pointer(subkey)), 0)
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func regSetValueEx(key syscall.Handle, valueName *uint16, reserved uint32, vtype uint32, buf *byte, bufsize uint32) (regerrno error) {
-        r0, _, _ := syscall.Syscall6(procRegSetValueExW.Addr(), 6, uintptr(key), uintptr(unsafe.Pointer(valueName)), uintptr(reserved), uintptr(vtype), uintptr(unsafe.Pointer(buf)), uintptr(bufsize))
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func regEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) {
-        r0, _, _ := syscall.Syscall9(procRegEnumValueW.Addr(), 8, uintptr(key), uintptr(index), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(valtype)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(buflen)), 0)
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func regDeleteValue(key syscall.Handle, name *uint16) (regerrno error) {
-        r0, _, _ := syscall.Syscall(procRegDeleteValueW.Addr(), 2, uintptr(key), uintptr(unsafe.Pointer(name)), 0)
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func regLoadMUIString(key syscall.Handle, name *uint16, buf *uint16, buflen uint32, buflenCopied *uint32, flags uint32, dir *uint16) (regerrno error) {
-        r0, _, _ := syscall.Syscall9(procRegLoadMUIStringW.Addr(), 7, uintptr(key), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buf)), uintptr(buflen), uintptr(unsafe.Pointer(buflenCopied)), uintptr(flags), uintptr(unsafe.Pointer(dir)), 0, 0)
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func regConnectRegistry(machinename *uint16, key syscall.Handle, result *syscall.Handle) (regerrno error) {
-        r0, _, _ := syscall.Syscall(procRegConnectRegistryW.Addr(), 3, uintptr(unsafe.Pointer(machinename)), uintptr(key), uintptr(unsafe.Pointer(result)))
-        if r0 != 0 {
-                regerrno = syscall.Errno(r0)
-        }
-        return
-}
-
-func expandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) {
-        r0, _, e1 := syscall.Syscall(procExpandEnvironmentStringsW.Addr(), 3, uintptr(unsafe.Pointer(src)), uintptr(unsafe.Pointer(dst)), uintptr(size))
-        n = uint32(r0)
-        if n == 0 {
-                if e1 != 0 {
-                        err = errnoErr(e1)
-                } else {
-                        err = syscall.EINVAL
-                }
-        }
-        return
-}
diff --git a/vendor/golang.org/x/sys/windows/svc/eventlog/install.go b/vendor/golang.org/x/sys/windows/svc/eventlog/install.go
deleted file mode 100644
index c76a376..0000000
--- a/vendor/golang.org/x/sys/windows/svc/eventlog/install.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2012 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.
-
-// +build windows
-
-package eventlog
-
-import (
-        "errors"
-
-        "golang.org/x/sys/windows"
-        "golang.org/x/sys/windows/registry"
-)
-
-const (
-        // Log levels.
-        Info    = windows.EVENTLOG_INFORMATION_TYPE
-        Warning = windows.EVENTLOG_WARNING_TYPE
-        Error   = windows.EVENTLOG_ERROR_TYPE
-)
-
-const addKeyName = `SYSTEM\CurrentControlSet\Services\EventLog\Application`
-
-// Install modifies PC registry to allow logging with an event source src.
-// It adds all required keys and values to the event log registry key.
-// Install uses msgFile as the event message file. If useExpandKey is true,
-// the event message file is installed as REG_EXPAND_SZ value,
-// otherwise as REG_SZ. Use bitwise of log.Error, log.Warning and
-// log.Info to specify events supported by the new event source.
-func Install(src, msgFile string, useExpandKey bool, eventsSupported uint32) error {
-        appkey, err := registry.OpenKey(registry.LOCAL_MACHINE, addKeyName, registry.CREATE_SUB_KEY)
-        if err != nil {
-                return err
-        }
-        defer appkey.Close()
-
-        sk, alreadyExist, err := registry.CreateKey(appkey, src, registry.SET_VALUE)
-        if err != nil {
-                return err
-        }
-        defer sk.Close()
-        if alreadyExist {
-                return errors.New(addKeyName + `\` + src + " registry key already exists")
-        }
-
-        err = sk.SetDWordValue("CustomSource", 1)
-        if err != nil {
-                return err
-        }
-        if useExpandKey {
-                err = sk.SetExpandStringValue("EventMessageFile", msgFile)
-        } else {
-                err = sk.SetStringValue("EventMessageFile", msgFile)
-        }
-        if err != nil {
-                return err
-        }
-        err = sk.SetDWordValue("TypesSupported", eventsSupported)
-        if err != nil {
-                return err
-        }
-        return nil
-}
-
-// InstallAsEventCreate is the same as Install, but uses
-// %SystemRoot%\System32\EventCreate.exe as the event message file.
-func InstallAsEventCreate(src string, eventsSupported uint32) error {
-        return Install(src, "%SystemRoot%\\System32\\EventCreate.exe", true, eventsSupported)
-}
-
-// Remove deletes all registry elements installed by the correspondent Install.
-func Remove(src string) error {
-        appkey, err := registry.OpenKey(registry.LOCAL_MACHINE, addKeyName, registry.SET_VALUE)
-        if err != nil {
-                return err
-        }
-        defer appkey.Close()
-        return registry.DeleteKey(appkey, src)
-}
diff --git a/vendor/golang.org/x/sys/windows/svc/eventlog/log.go b/vendor/golang.org/x/sys/windows/svc/eventlog/log.go
deleted file mode 100644
index 46e5153..0000000
--- a/vendor/golang.org/x/sys/windows/svc/eventlog/log.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2012 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.
-
-// +build windows
-
-// Package eventlog implements access to Windows event log.
-//
-package eventlog
-
-import (
-        "errors"
-        "syscall"
-
-        "golang.org/x/sys/windows"
-)
-
-// Log provides access to the system log.
-type Log struct {
-        Handle windows.Handle
-}
-
-// Open retrieves a handle to the specified event log.
-func Open(source string) (*Log, error) {
-        return OpenRemote("", source)
-}
-
-// OpenRemote does the same as Open, but on different computer host.
-func OpenRemote(host, source string) (*Log, error) {
-        if source == "" {
-                return nil, errors.New("Specify event log source")
-        }
-        var s *uint16
-        if host != "" {
-                s = syscall.StringToUTF16Ptr(host)
-        }
-        h, err := windows.RegisterEventSource(s, syscall.StringToUTF16Ptr(source))
-        if err != nil {
-                return nil, err
-        }
-        return &Log{Handle: h}, nil
-}
-
-// Close closes event log l.
-func (l *Log) Close() error {
-        return windows.DeregisterEventSource(l.Handle)
-}
-
-func (l *Log) report(etype uint16, eid uint32, msg string) error {
-        ss := []*uint16{syscall.StringToUTF16Ptr(msg)}
-        return windows.ReportEvent(l.Handle, etype, 0, eid, 0, 1, 0, &ss[0], nil)
-}
-
-// Info writes an information event msg with event id eid to the end of event log l.
-// When EventCreate.exe is used, eid must be between 1 and 1000.
-func (l *Log) Info(eid uint32, msg string) error {
-        return l.report(windows.EVENTLOG_INFORMATION_TYPE, eid, msg)
-}
-
-// Warning writes an warning event msg with event id eid to the end of event log l.
-// When EventCreate.exe is used, eid must be between 1 and 1000.
-func (l *Log) Warning(eid uint32, msg string) error {
-        return l.report(windows.EVENTLOG_WARNING_TYPE, eid, msg)
-}
-
-// Error writes an error event msg with event id eid to the end of event log l.
-// When EventCreate.exe is used, eid must be between 1 and 1000.
-func (l *Log) Error(eid uint32, msg string) error {
-        return l.report(windows.EVENTLOG_ERROR_TYPE, eid, msg)
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 4d02fda..b81ffcb 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -11,14 +11,19 @@ github.com/beorn7/perks/quantile
 github.com/coreos/go-systemd/dbus
 # github.com/ema/qdisc v0.0.0-20190904071900-b82c76788043
 github.com/ema/qdisc
+# github.com/go-kit/kit v0.9.0
+github.com/go-kit/kit/log
+github.com/go-kit/kit/log/level
+# github.com/go-logfmt/logfmt v0.4.0
+github.com/go-logfmt/logfmt
 # github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968
 github.com/godbus/dbus
 # github.com/golang/protobuf v1.3.2
 github.com/golang/protobuf/proto
 # github.com/hodgesds/perf-utils v0.0.7
 github.com/hodgesds/perf-utils
-# github.com/konsorten/go-windows-terminal-sequences v1.0.2
-github.com/konsorten/go-windows-terminal-sequences
+# github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515
+github.com/kr/logfmt
 # github.com/lufia/iostat v0.0.0-20170605150913-9f7362b77ad3
 github.com/lufia/iostat
 # github.com/mattn/go-xmlrpc v0.0.3
@@ -44,8 +49,9 @@ github.com/prometheus/client_model/go
 # github.com/prometheus/common v0.7.0
 github.com/prometheus/common/expfmt
 github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg
-github.com/prometheus/common/log
 github.com/prometheus/common/model
+github.com/prometheus/common/promlog
+github.com/prometheus/common/promlog/flag
 github.com/prometheus/common/version
 # github.com/prometheus/procfs v0.0.8
 github.com/prometheus/procfs
@@ -57,8 +63,6 @@ github.com/prometheus/procfs/sysfs
 github.com/prometheus/procfs/xfs
 # github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745
 github.com/siebenmann/go-kstat
-# github.com/sirupsen/logrus v1.4.2
-github.com/sirupsen/logrus
 # github.com/soundcloud/go-runit v0.0.0-20150630195641-06ad41a06c4a
 github.com/soundcloud/go-runit/runit
 # go.uber.org/atomic v1.3.2
@@ -75,8 +79,6 @@ golang.org/x/sync/errgroup
 # golang.org/x/sys v0.0.0-20190902133755-9109b7679e13
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-golang.org/x/sys/windows/registry
-golang.org/x/sys/windows/svc/eventlog
 # gopkg.in/alecthomas/kingpin.v2 v2.2.6
 gopkg.in/alecthomas/kingpin.v2
 # gopkg.in/yaml.v2 v2.2.2