mirror of
https://github.com/rclone/rclone.git
synced 2024-12-29 10:29:29 +01:00
115 lines
3.2 KiB
Go
115 lines
3.2 KiB
Go
// 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"
|
|
}
|