func report(err error, linePrefix string) error {
var reportersCopy []ErrorReporter
reportersMutex.RLock()
if len(reporters) > 0 {
reportersCopy = make([]ErrorReporter, len(reporters))
copy(reportersCopy, reporters)
}
reportersMutex.RUnlock()
if len(reportersCopy) > 0 {
ctx := ops.AsMap(err, true)
for _, reporter := range reportersCopy {
// We include globals when reporting
reporter(err, linePrefix, ctx)
}
}
return err
}
func printContext(buf *bytes.Buffer, err interface{}) {
// Note - we don't include globals when printing in order to avoid polluting the text log
values := ops.AsMap(err, false)
if len(values) == 0 {
return
}
buf.WriteString(" [")
var keys []string
for key := range values {
keys = append(keys, key)
}
sort.Strings(keys)
for i, key := range keys {
value := values[key]
if i > 0 {
buf.WriteString(" ")
}
buf.WriteString(key)
buf.WriteString("=")
fmt.Fprintf(buf, "%v", value)
}
buf.WriteByte(']')
}
func buildError(desc string, fullText string, wrapped error, cause Error) *structured {
e := &structured{
data: make(context.Map),
// We capture the current context to allow it to propagate to higher layers.
context: ops.AsMap(nil, false),
wrapped: wrapped,
cause: cause,
}
e.save()
errorType := "errors.Error"
if wrapped != nil {
op, goType, wrappedDesc, extra := parseError(wrapped)
if desc == "" {
desc = wrappedDesc
}
e.Op(op)
errorType = goType
if extra != nil {
for key, value := range extra {
e.data[key] = value
}
}
}
cleanedDesc := hidden.Clean(desc)
e.data["error"] = cleanedDesc
if fullText != "" {
e.data["error_text"] = hidden.Clean(fullText)
} else {
e.data["error_text"] = cleanedDesc
}
e.data["error_type"] = errorType
return e
}