Tardigrade Backend: Dependencies

vendor/github.com/spacemonkeygo/monkit/v3/error_names.go

@@ -0,0 +1,114 @@
+// Copyright (C) 2017 Space Monkey, Inc.
+//
+// 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 monkit
+
+import (
+	"context"
+	"io"
+	"net"
+	"os"
+	"sync"
+	"sync/atomic"
+)
+
+// errorNameHandlers keeps track of the list of error name handlers monkit will
+// call to give errors good metric names.
+var errorNameHandlers struct {
+	write_mu sync.Mutex
+	value    atomic.Value
+}
+
+// AddErrorNameHandler adds an error name handler function that will be
+// consulted every time an error is captured for a task. The handlers will be
+// called in the order they were registered with the most recently added
+// handler first, until a handler returns true for the second return value.
+// If no handler returns true, the error is checked to see if it implements
+// an interface that allows it to name itself, and otherwise, monkit attempts
+// to find a good name for most built in Go standard library errors.
+func AddErrorNameHandler(f func(error) (string, bool)) {
+	errorNameHandlers.write_mu.Lock()
+	defer errorNameHandlers.write_mu.Unlock()
+
+	handlers, _ := errorNameHandlers.value.Load().([]func(error) (string, bool))
+	handlers = append(handlers, f)
+	errorNameHandlers.value.Store(handlers)
+}
+
+// getErrorName implements the logic described in the AddErrorNameHandler
+// function.
+func getErrorName(err error) string {
+	// check if any of the handlers will handle it
+	handlers, _ := errorNameHandlers.value.Load().([]func(error) (string, bool))
+	for i := len(handlers) - 1; i >= 0; i-- {
+		if name, ok := handlers[i](err); ok {
+			return name
+		}
+	}
+
+	// check if it knows how to name itself
+	type namer interface {
+		Name() (string, bool)
+	}
+
+	if n, ok := err.(namer); ok {
+		if name, ok := n.Name(); ok {
+			return name
+		}
+	}
+
+	// check if it's a known error that we handle to give good names
+	switch err {
+	case io.EOF:
+		return "EOF"
+	case io.ErrUnexpectedEOF:
+		return "Unexpected EOF Error"
+	case io.ErrClosedPipe:
+		return "Closed Pipe Error"
+	case io.ErrNoProgress:
+		return "No Progress Error"
+	case io.ErrShortBuffer:
+		return "Short Buffer Error"
+	case io.ErrShortWrite:
+		return "Short Write Error"
+	case context.Canceled:
+		return "Canceled"
+	case context.DeadlineExceeded:
+		return "Timeout"
+	}
+	if isErrnoError(err) {
+		return "Errno"
+	}
+	switch err.(type) {
+	case *os.SyscallError:
+		return "Syscall Error"
+	case net.UnknownNetworkError:
+		return "Unknown Network Error"
+	case *net.AddrError:
+		return "Addr Error"
+	case net.InvalidAddrError:
+		return "Invalid Addr Error"
+	case *net.OpError:
+		return "Net Op Error"
+	case *net.ParseError:
+		return "Net Parse Error"
+	case *net.DNSError:
+		return "DNS Error"
+	case *net.DNSConfigError:
+		return "DNS Config Error"
+	case net.Error:
+		return "Network Error"
+	}
+	return "System Error"
+}