7 files changed, 871 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/go-hclog/LICENSE b/vendor/github.com/hashicorp/go-hclog/LICENSE
new file mode 100644
index 0000000..abaf1e4
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 HashiCorp
+
+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/hashicorp/go-hclog/README.md b/vendor/github.com/hashicorp/go-hclog/README.md
new file mode 100644
index 0000000..614342b
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/README.md
@@ -0,0 +1,123 @@
+# go-hclog
+
+[![Go Documentation](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)][godocs]
+
+[godocs]: https://godoc.org/github.com/hashicorp/go-hclog
+
+`go-hclog` is a package for Go that provides a simple key/value logging
+interface for use in development and production environments.
+
+It provides logging levels that provide decreased output based upon the
+desired amount of output, unlike the standard library `log` package.
+
+It does not provide `Printf` style logging, only key/value logging that is
+exposed as arguments to the logging functions for simplicity.
+
+It provides a human readable output mode for use in development as well as
+JSON output mode for production.
+
+## Stability Note
+
+While this library is fully open source and HashiCorp will be maintaining it
+(since we are and will be making extensive use of it), the API and output
+format is subject to minor changes as we fully bake and vet it in our projects.
+This notice will be removed once it's fully integrated into our major projects
+and no further changes are anticipated.
+
+## Installation and Docs
+
+Install using `go get github.com/hashicorp/go-hclog`.
+
+Full documentation is available at
+http://godoc.org/github.com/hashicorp/go-hclog
+
+## Usage
+
+### Use the global logger
+
+```go
+hclog.Default().Info("hello world")
+```
+
+```text
+2017-07-05T16:15:55.167-0700 [INFO ] hello world
+```
+
+(Note timestamps are removed in future examples for brevity.)
+
+### Create a new logger
+
+```go
+appLogger := hclog.New(&hclog.LoggerOptions{
+        Name:  "my-app",
+        Level: hclog.LevelFromString("DEBUG"),
+})
+```
+
+### Emit an Info level message with 2 key/value pairs
+
+```go
+input := "5.5"
+_, err := strconv.ParseInt(input, 10, 32)
+if err != nil {
+        appLogger.Info("Invalid input for ParseInt", "input", input, "error", err)
+}
+```
+
+```text
+... [INFO ] my-app: Invalid input for ParseInt: input=5.5 error="strconv.ParseInt: parsing "5.5": invalid syntax"
+```
+
+### Create a new Logger for a major subsystem
+
+```go
+subsystemLogger := appLogger.Named("transport")
+subsystemLogger.Info("we are transporting something")
+```
+
+```text
+... [INFO ] my-app.transport: we are transporting something
+```
+
+Notice that logs emitted by `subsystemLogger` contain `my-app.transport`,
+reflecting both the application and subsystem names.
+
+### Create a new Logger with fixed key/value pairs
+
+Using `With()` will include a specific key-value pair in all messages emitted
+by that logger.
+
+```go
+requestID := "5fb446b6-6eba-821d-df1b-cd7501b6a363"
+requestLogger := subsystemLogger.With("request", requestID)
+requestLogger.Info("we are transporting a request")
+```
+
+```text
+... [INFO ] my-app.transport: we are transporting a request: request=5fb446b6-6eba-821d-df1b-cd7501b6a363
+```
+
+This allows sub Loggers to be context specific without having to thread that
+into all the callers.
+
+### Use this with code that uses the standard library logger
+
+If you want to use the standard library's `log.Logger` interface you can wrap
+`hclog.Logger` by calling the `StandardLogger()` method. This allows you to use
+it with the familiar `Println()`, `Printf()`, etc. For example:
+
+```go
+stdLogger := appLogger.StandardLogger(&hclog.StandardLoggerOptions{
+        InferLevels: true,
+})
+// Printf() is provided by stdlib log.Logger interface, not hclog.Logger
+stdLogger.Printf("[DEBUG] %+v", stdLogger)
+```
+
+```text
+... [DEBUG] my-app: &{mu:{state:0 sema:0} prefix: flag:0 out:0xc42000a0a0 buf:[]}
+```
+
+Notice that if `appLogger` is initialized with the `INFO` log level _and_ you
+specify `InferLevels: true`, you will not see any output here. You must change
+`appLogger` to `DEBUG` to see output. See the docs for more information.
diff --git a/vendor/github.com/hashicorp/go-hclog/global.go b/vendor/github.com/hashicorp/go-hclog/global.go
new file mode 100644
index 0000000..55ce439
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/global.go
@@ -0,0 +1,34 @@
+package hclog
+
+import (
+        "sync"
+)
+
+var (
+        protect sync.Once
+        def     Logger
+
+        // The options used to create the Default logger. These are
+        // read only when the Default logger is created, so set them
+        // as soon as the process starts.
+        DefaultOptions = &LoggerOptions{
+                Level:  DefaultLevel,
+                Output: DefaultOutput,
+        }
+)
+
+// Return a logger that is held globally. This can be a good starting
+// place, and then you can use .With() and .Name() to create sub-loggers
+// to be used in more specific contexts.
+func Default() Logger {
+        protect.Do(func() {
+                def = New(DefaultOptions)
+        })
+
+        return def
+}
+
+// A short alias for Default()
+func L() Logger {
+        return Default()
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/int.go b/vendor/github.com/hashicorp/go-hclog/int.go
new file mode 100644
index 0000000..9f90c28
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/int.go
@@ -0,0 +1,385 @@
+package hclog
+
+import (
+        "bufio"
+        "encoding/json"
+        "fmt"
+        "log"
+        "os"
+        "runtime"
+        "strconv"
+        "strings"
+        "sync"
+        "time"
+)
+
+var (
+        _levelToBracket = map[Level]string{
+                Debug: "[DEBUG]",
+                Trace: "[TRACE]",
+                Info:  "[INFO ]",
+                Warn:  "[WARN ]",
+                Error: "[ERROR]",
+        }
+)
+
+// Given the options (nil for defaults), create a new Logger
+func New(opts *LoggerOptions) Logger {
+        if opts == nil {
+                opts = &LoggerOptions{}
+        }
+
+        output := opts.Output
+        if output == nil {
+                output = os.Stderr
+        }
+
+        level := opts.Level
+        if level == NoLevel {
+                level = DefaultLevel
+        }
+
+        return &intLogger{
+                m:      new(sync.Mutex),
+                json:   opts.JSONFormat,
+                caller: opts.IncludeLocation,
+                name:   opts.Name,
+                w:      bufio.NewWriter(output),
+                level:  level,
+        }
+}
+
+// The internal logger implementation. Internal in that it is defined entirely
+// by this package.
+type intLogger struct {
+        json   bool
+        caller bool
+        name   string
+
+        // this is a pointer so that it's shared by any derived loggers, since
+        // those derived loggers share the bufio.Writer as well.
+        m     *sync.Mutex
+        w     *bufio.Writer
+        level Level
+
+        implied []interface{}
+}
+
+// Make sure that intLogger is a Logger
+var _ Logger = &intLogger{}
+
+// The time format to use for logging. This is a version of RFC3339 that
+// contains millisecond precision
+const TimeFormat = "2006-01-02T15:04:05.000Z0700"
+
+// Log a message and a set of key/value pairs if the given level is at
+// or more severe that the threshold configured in the Logger.
+func (z *intLogger) Log(level Level, msg string, args ...interface{}) {
+        if level < z.level {
+                return
+        }
+
+        t := time.Now()
+
+        z.m.Lock()
+        defer z.m.Unlock()
+
+        if z.json {
+                z.logJson(t, level, msg, args...)
+        } else {
+                z.log(t, level, msg, args...)
+        }
+
+        z.w.Flush()
+}
+
+// Cleanup a path by returning the last 2 segments of the path only.
+func trimCallerPath(path string) string {
+        // lovely borrowed from zap
+        // nb. To make sure we trim the path correctly on Windows too, we
+        // counter-intuitively need to use '/' and *not* os.PathSeparator here,
+        // because the path given originates from Go stdlib, specifically
+        // runtime.Caller() which (as of Mar/17) returns forward slashes even on
+        // Windows.
+        //
+        // See https://github.com/golang/go/issues/3335
+        // and https://github.com/golang/go/issues/18151
+        //
+        // for discussion on the issue on Go side.
+        //
+
+        // Find the last separator.
+        //
+        idx := strings.LastIndexByte(path, '/')
+        if idx == -1 {
+                return path
+        }
+
+        // Find the penultimate separator.
+        idx = strings.LastIndexByte(path[:idx], '/')
+        if idx == -1 {
+                return path
+        }
+
+        return path[idx+1:]
+}
+
+// Non-JSON logging format function
+func (z *intLogger) log(t time.Time, level Level, msg string, args ...interface{}) {
+        z.w.WriteString(t.Format(TimeFormat))
+        z.w.WriteByte(' ')
+
+        s, ok := _levelToBracket[level]
+        if ok {
+                z.w.WriteString(s)
+        } else {
+                z.w.WriteString("[UNKN ]")
+        }
+
+        if z.caller {
+                if _, file, line, ok := runtime.Caller(3); ok {
+                        z.w.WriteByte(' ')
+                        z.w.WriteString(trimCallerPath(file))
+                        z.w.WriteByte(':')
+                        z.w.WriteString(strconv.Itoa(line))
+                        z.w.WriteByte(':')
+                }
+        }
+
+        z.w.WriteByte(' ')
+
+        if z.name != "" {
+                z.w.WriteString(z.name)
+                z.w.WriteString(": ")
+        }
+
+        z.w.WriteString(msg)
+
+        args = append(z.implied, args...)
+
+        var stacktrace CapturedStacktrace
+
+        if args != nil && len(args) > 0 {
+                if len(args)%2 != 0 {
+                        cs, ok := args[len(args)-1].(CapturedStacktrace)
+                        if ok {
+                                args = args[:len(args)-1]
+                                stacktrace = cs
+                        } else {
+                                args = append(args, "<unknown>")
+                        }
+                }
+
+                z.w.WriteByte(':')
+
+        FOR:
+                for i := 0; i < len(args); i = i + 2 {
+                        var val string
+
+                        switch st := args[i+1].(type) {
+                        case string:
+                                val = st
+                        case int:
+                                val = strconv.FormatInt(int64(st), 10)
+                        case int64:
+                                val = strconv.FormatInt(int64(st), 10)
+                        case int32:
+                                val = strconv.FormatInt(int64(st), 10)
+                        case int16:
+                                val = strconv.FormatInt(int64(st), 10)
+                        case int8:
+                                val = strconv.FormatInt(int64(st), 10)
+                        case uint:
+                                val = strconv.FormatUint(uint64(st), 10)
+                        case uint64:
+                                val = strconv.FormatUint(uint64(st), 10)
+                        case uint32:
+                                val = strconv.FormatUint(uint64(st), 10)
+                        case uint16:
+                                val = strconv.FormatUint(uint64(st), 10)
+                        case uint8:
+                                val = strconv.FormatUint(uint64(st), 10)
+                        case CapturedStacktrace:
+                                stacktrace = st
+                                continue FOR
+                        default:
+                                val = fmt.Sprintf("%v", st)
+                        }
+
+                        z.w.WriteByte(' ')
+                        z.w.WriteString(args[i].(string))
+                        z.w.WriteByte('=')
+
+                        if strings.ContainsAny(val, " \t\n\r") {
+                                z.w.WriteByte('"')
+                                z.w.WriteString(val)
+                                z.w.WriteByte('"')
+                        } else {
+                                z.w.WriteString(val)
+                        }
+                }
+        }
+
+        z.w.WriteString("\n")
+
+        if stacktrace != "" {
+                z.w.WriteString(string(stacktrace))
+        }
+}
+
+// JSON logging function
+func (z *intLogger) logJson(t time.Time, level Level, msg string, args ...interface{}) {
+        vals := map[string]interface{}{
+                "@message":   msg,
+                "@timestamp": t.Format("2006-01-02T15:04:05.000000Z07:00"),
+        }
+
+        var levelStr string
+        switch level {
+        case Error:
+                levelStr = "error"
+        case Warn:
+                levelStr = "warn"
+        case Info:
+                levelStr = "info"
+        case Debug:
+                levelStr = "debug"
+        case Trace:
+                levelStr = "trace"
+        default:
+                levelStr = "all"
+        }
+
+        vals["@level"] = levelStr
+
+        if z.name != "" {
+                vals["@module"] = z.name
+        }
+
+        if z.caller {
+                if _, file, line, ok := runtime.Caller(3); ok {
+                        vals["@caller"] = fmt.Sprintf("%s:%d", file, line)
+                }
+        }
+
+        if args != nil && len(args) > 0 {
+                if len(args)%2 != 0 {
+                        cs, ok := args[len(args)-1].(CapturedStacktrace)
+                        if ok {
+                                args = args[:len(args)-1]
+                                vals["stacktrace"] = cs
+                        } else {
+                                args = append(args, "<unknown>")
+                        }
+                }
+
+                for i := 0; i < len(args); i = i + 2 {
+                        if _, ok := args[i].(string); !ok {
+                                // As this is the logging function not much we can do here
+                                // without injecting into logs...
+                                continue
+                        }
+                        vals[args[i].(string)] = args[i+1]
+                }
+        }
+
+        err := json.NewEncoder(z.w).Encode(vals)
+        if err != nil {
+                panic(err)
+        }
+}
+
+// Emit the message and args at DEBUG level
+func (z *intLogger) Debug(msg string, args ...interface{}) {
+        z.Log(Debug, msg, args...)
+}
+
+// Emit the message and args at TRACE level
+func (z *intLogger) Trace(msg string, args ...interface{}) {
+        z.Log(Trace, msg, args...)
+}
+
+// Emit the message and args at INFO level
+func (z *intLogger) Info(msg string, args ...interface{}) {
+        z.Log(Info, msg, args...)
+}
+
+// Emit the message and args at WARN level
+func (z *intLogger) Warn(msg string, args ...interface{}) {
+        z.Log(Warn, msg, args...)
+}
+
+// Emit the message and args at ERROR level
+func (z *intLogger) Error(msg string, args ...interface{}) {
+        z.Log(Error, msg, args...)
+}
+
+// Indicate that the logger would emit TRACE level logs
+func (z *intLogger) IsTrace() bool {
+        return z.level == Trace
+}
+
+// Indicate that the logger would emit DEBUG level logs
+func (z *intLogger) IsDebug() bool {
+        return z.level <= Debug
+}
+
+// Indicate that the logger would emit INFO level logs
+func (z *intLogger) IsInfo() bool {
+        return z.level <= Info
+}
+
+// Indicate that the logger would emit WARN level logs
+func (z *intLogger) IsWarn() bool {
+        return z.level <= Warn
+}
+
+// Indicate that the logger would emit ERROR level logs
+func (z *intLogger) IsError() bool {
+        return z.level <= Error
+}
+
+// Return a sub-Logger for which every emitted log message will contain
+// the given key/value pairs. This is used to create a context specific
+// Logger.
+func (z *intLogger) With(args ...interface{}) Logger {
+        var nz intLogger = *z
+
+        nz.implied = append(nz.implied, args...)
+
+        return &nz
+}
+
+// Create a new sub-Logger that a name decending from the current name.
+// This is used to create a subsystem specific Logger.
+func (z *intLogger) Named(name string) Logger {
+        var nz intLogger = *z
+
+        if nz.name != "" {
+                nz.name = nz.name + "." + name
+        }
+
+        return &nz
+}
+
+// Create a new sub-Logger with an explicit name. This ignores the current
+// name. This is used to create a standalone logger that doesn't fall
+// within the normal hierarchy.
+func (z *intLogger) ResetNamed(name string) Logger {
+        var nz intLogger = *z
+
+        nz.name = name
+
+        return &nz
+}
+
+// Create a *log.Logger that will send it's data through this Logger. This
+// allows packages that expect to be using the standard library log to actually
+// use this logger.
+func (z *intLogger) StandardLogger(opts *StandardLoggerOptions) *log.Logger {
+        if opts == nil {
+                opts = &StandardLoggerOptions{}
+        }
+
+        return log.New(&stdlogAdapter{z, opts.InferLevels}, "", 0)
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/log.go b/vendor/github.com/hashicorp/go-hclog/log.go
new file mode 100644
index 0000000..6bb16ba
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/log.go
@@ -0,0 +1,138 @@
+package hclog
+
+import (
+        "io"
+        "log"
+        "os"
+        "strings"
+)
+
+var (
+        DefaultOutput = os.Stderr
+        DefaultLevel  = Info
+)
+
+type Level int
+
+const (
+        // This is a special level used to indicate that no level has been
+        // set and allow for a default to be used.
+        NoLevel Level = 0
+
+        // The most verbose level. Intended to be used for the tracing of actions
+        // in code, such as function enters/exits, etc.
+        Trace Level = 1
+
+        // For programmer lowlevel analysis.
+        Debug Level = 2
+
+        // For information about steady state operations.
+        Info Level = 3
+
+        // For information about rare but handled events.
+        Warn Level = 4
+
+        // For information about unrecoverable events.
+        Error Level = 5
+)
+
+// LevelFromString returns a Level type for the named log level, or "NoLevel" if
+// the level string is invalid. This facilitates setting the log level via
+// config or environment variable by name in a predictable way.
+func LevelFromString(levelStr string) Level {
+        // We don't care about case. Accept "INFO" or "info"
+        levelStr = strings.ToLower(strings.TrimSpace(levelStr))
+        switch levelStr {
+        case "trace":
+                return Trace
+        case "debug":
+                return Debug
+        case "info":
+                return Info
+        case "warn":
+                return Warn
+        case "error":
+                return Error
+        default:
+                return NoLevel
+        }
+}
+
+// The main Logger interface. All code should code against this interface only.
+type Logger interface {
+        // Args are alternating key, val pairs
+        // keys must be strings
+        // vals can be any type, but display is implementation specific
+        // Emit a message and key/value pairs at the TRACE level
+        Trace(msg string, args ...interface{})
+
+        // Emit a message and key/value pairs at the DEBUG level
+        Debug(msg string, args ...interface{})
+
+        // Emit a message and key/value pairs at the INFO level
+        Info(msg string, args ...interface{})
+
+        // Emit a message and key/value pairs at the WARN level
+        Warn(msg string, args ...interface{})
+
+        // Emit a message and key/value pairs at the ERROR level
+        Error(msg string, args ...interface{})
+
+        // Indicate if TRACE logs would be emitted. This and the other Is* guards
+        // are used to elide expensive logging code based on the current level.
+        IsTrace() bool
+
+        // Indicate if DEBUG logs would be emitted. This and the other Is* guards
+        IsDebug() bool
+
+        // Indicate if INFO logs would be emitted. This and the other Is* guards
+        IsInfo() bool
+
+        // Indicate if WARN logs would be emitted. This and the other Is* guards
+        IsWarn() bool
+
+        // Indicate if ERROR logs would be emitted. This and the other Is* guards
+        IsError() bool
+
+        // Creates a sublogger that will always have the given key/value pairs
+        With(args ...interface{}) Logger
+
+        // Create a logger that will prepend the name string on the front of all messages.
+        // If the logger already has a name, the new value will be appended to the current
+        // name. That way, a major subsystem can use this to decorate all it's own logs
+        // without losing context.
+        Named(name string) Logger
+
+        // Create a logger that will prepend the name string on the front of all messages.
+        // This sets the name of the logger to the value directly, unlike Named which honor
+        // the current name as well.
+        ResetNamed(name string) Logger
+
+        // Return a value that conforms to the stdlib log.Logger interface
+        StandardLogger(opts *StandardLoggerOptions) *log.Logger
+}
+
+type StandardLoggerOptions struct {
+        // Indicate that some minimal parsing should be done on strings to try
+        // and detect their level and re-emit them.
+        // This supports the strings like [ERROR], [ERR] [TRACE], [WARN], [INFO],
+        // [DEBUG] and strip it off before reapplying it.
+        InferLevels bool
+}
+
+type LoggerOptions struct {
+        // Name of the subsystem to prefix logs with
+        Name string
+
+        // The threshold for the logger. Anything less severe is supressed
+        Level Level
+
+        // Where to write the logs to. Defaults to os.Stdout if nil
+        Output io.Writer
+
+        // Control if the output should be in JSON.
+        JSONFormat bool
+
+        // Intclude file and line information in each log line
+        IncludeLocation bool
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/stacktrace.go b/vendor/github.com/hashicorp/go-hclog/stacktrace.go
new file mode 100644
index 0000000..8af1a3b
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/stacktrace.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2016 Uber Technologies, Inc.
+//
+// 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.
+
+package hclog
+
+import (
+        "bytes"
+        "runtime"
+        "strconv"
+        "strings"
+        "sync"
+)
+
+var (
+        _stacktraceIgnorePrefixes = []string{
+                "runtime.goexit",
+                "runtime.main",
+        }
+        _stacktracePool = sync.Pool{
+                New: func() interface{} {
+                        return newProgramCounters(64)
+                },
+        }
+)
+
+// A stacktrace gathered by a previous call to log.Stacktrace. If passed
+// to a logging function, the stacktrace will be appended.
+type CapturedStacktrace string
+
+// Gather a stacktrace of the current goroutine and return it to be passed
+// to a logging function.
+func Stacktrace() CapturedStacktrace {
+        return CapturedStacktrace(takeStacktrace())
+}
+
+func takeStacktrace() string {
+        programCounters := _stacktracePool.Get().(*programCounters)
+        defer _stacktracePool.Put(programCounters)
+
+        var buffer bytes.Buffer
+
+        for {
+                // Skip the call to runtime.Counters and takeStacktrace so that the
+                // program counters start at the caller of takeStacktrace.
+                n := runtime.Callers(2, programCounters.pcs)
+                if n < cap(programCounters.pcs) {
+                        programCounters.pcs = programCounters.pcs[:n]
+                        break
+                }
+                // Don't put the too-short counter slice back into the pool; this lets
+                // the pool adjust if we consistently take deep stacktraces.
+                programCounters = newProgramCounters(len(programCounters.pcs) * 2)
+        }
+
+        i := 0
+        frames := runtime.CallersFrames(programCounters.pcs)
+        for frame, more := frames.Next(); more; frame, more = frames.Next() {
+                if shouldIgnoreStacktraceFunction(frame.Function) {
+                        continue
+                }
+                if i != 0 {
+                        buffer.WriteByte('\n')
+                }
+                i++
+                buffer.WriteString(frame.Function)
+                buffer.WriteByte('\n')
+                buffer.WriteByte('\t')
+                buffer.WriteString(frame.File)
+                buffer.WriteByte(':')
+                buffer.WriteString(strconv.Itoa(int(frame.Line)))
+        }
+
+        return buffer.String()
+}
+
+func shouldIgnoreStacktraceFunction(function string) bool {
+        for _, prefix := range _stacktraceIgnorePrefixes {
+                if strings.HasPrefix(function, prefix) {
+                        return true
+                }
+        }
+        return false
+}
+
+type programCounters struct {
+        pcs []uintptr
+}
+
+func newProgramCounters(size int) *programCounters {
+        return &programCounters{make([]uintptr, size)}
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/stdlog.go b/vendor/github.com/hashicorp/go-hclog/stdlog.go
new file mode 100644
index 0000000..2bb927f
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/stdlog.go
@@ -0,0 +1,62 @@
+package hclog
+
+import (
+        "bytes"
+        "strings"
+)
+
+// Provides a io.Writer to shim the data out of *log.Logger
+// and back into our Logger. This is basically the only way to
+// build upon *log.Logger.
+type stdlogAdapter struct {
+        hl          Logger
+        inferLevels bool
+}
+
+// Take the data, infer the levels if configured, and send it through
+// a regular Logger
+func (s *stdlogAdapter) Write(data []byte) (int, error) {
+        str := string(bytes.TrimRight(data, " \t\n"))
+
+        if s.inferLevels {
+                level, str := s.pickLevel(str)
+                switch level {
+                case Trace:
+                        s.hl.Trace(str)
+                case Debug:
+                        s.hl.Debug(str)
+                case Info:
+                        s.hl.Info(str)
+                case Warn:
+                        s.hl.Warn(str)
+                case Error:
+                        s.hl.Error(str)
+                default:
+                        s.hl.Info(str)
+                }
+        } else {
+                s.hl.Info(str)
+        }
+
+        return len(data), nil
+}
+
+// Detect, based on conventions, what log level this is
+func (s *stdlogAdapter) pickLevel(str string) (Level, string) {
+        switch {
+        case strings.HasPrefix(str, "[DEBUG]"):
+                return Debug, strings.TrimSpace(str[7:])
+        case strings.HasPrefix(str, "[TRACE]"):
+                return Trace, strings.TrimSpace(str[7:])
+        case strings.HasPrefix(str, "[INFO]"):
+                return Info, strings.TrimSpace(str[6:])
+        case strings.HasPrefix(str, "[WARN]"):
+                return Warn, strings.TrimSpace(str[7:])
+        case strings.HasPrefix(str, "[ERROR]"):
+                return Error, strings.TrimSpace(str[7:])
+        case strings.HasPrefix(str, "[ERR]"):
+                return Error, strings.TrimSpace(str[5:])
+        default:
+                return Info, str
+        }
+}