Upgrade versions of vendored libs

vendor/github.com/getsentry/sentry-go/stacktrace.go

@@ -2,7 +2,6 @@ package sentry
 
 import (
 	"go/build"
-	"path/filepath"
 	"reflect"
 	"runtime"
 	"strings"
@@ -32,8 +31,8 @@ func NewStacktrace() *Stacktrace {
 		return nil
 	}
 
-	frames := extractFrames(pcs[:n])
-	frames = filterFrames(frames)
+	runtimeFrames := extractFrames(pcs[:n])
+	frames := createFrames(runtimeFrames)
 
 	stacktrace := Stacktrace{
 		Frames: frames,
@@ -62,8 +61,8 @@ func ExtractStacktrace(err error) *Stacktrace {
 		return nil
 	}
 
-	frames := extractFrames(pcs)
-	frames = filterFrames(frames)
+	runtimeFrames := extractFrames(pcs)
+	frames := createFrames(runtimeFrames)
 
 	stacktrace := Stacktrace{
 		Frames: frames,
@@ -174,7 +173,7 @@ type Frame struct {
 	PreContext  []string               `json:"pre_context,omitempty"`
 	ContextLine string                 `json:"context_line,omitempty"`
 	PostContext []string               `json:"post_context,omitempty"`
-	InApp       bool                   `json:"in_app,omitempty"`
+	InApp       bool                   `json:"in_app"`
 	Vars        map[string]interface{} `json:"vars,omitempty"`
 	// Package and the below are not used for Go stack trace frames.  In
 	// other platforms it refers to a container where the Module can be
@@ -192,34 +191,6 @@ type Frame struct {
 
 // NewFrame assembles a stacktrace frame out of runtime.Frame.
 func NewFrame(f runtime.Frame) Frame {
-	var abspath, relpath string
-	// NOTE: f.File paths historically use forward slash as path separator even
-	// on Windows, though this is not yet documented, see
-	// https://golang.org/issues/3335. In any case, filepath.IsAbs can work with
-	// paths with either slash or backslash on Windows.
-	switch {
-	case f.File == "":
-		relpath = unknown
-		// Leave abspath as the empty string to be omitted when serializing
-		// event as JSON.
-		abspath = ""
-	case filepath.IsAbs(f.File):
-		abspath = f.File
-		// TODO: in the general case, it is not trivial to come up with a
-		// "project relative" path with the data we have in run time.
-		// We shall not use filepath.Base because it creates ambiguous paths and
-		// affects the "Suspect Commits" feature.
-		// For now, leave relpath empty to be omitted when serializing the event
-		// as JSON. Improve this later.
-		relpath = ""
-	default:
-		// f.File is a relative path. This may happen when the binary is built
-		// with the -trimpath flag.
-		relpath = f.File
-		// Omit abspath when serializing the event as JSON.
-		abspath = ""
-	}
-
 	function := f.Function
 	var pkg string
 
@@ -227,15 +198,56 @@ func NewFrame(f runtime.Frame) Frame {
 		pkg, function = splitQualifiedFunctionName(function)
 	}
 
+	return newFrame(pkg, function, f.File, f.Line)
+}
+
+// Like filepath.IsAbs() but doesn't care what platform you run this on.
+// I.e. it also recognizies `/path/to/file` when run on Windows.
+func isAbsPath(path string) bool {
+	if len(path) == 0 {
+		return false
+	}
+
+	// If the volume name starts with a double slash, this is an absolute path.
+	if len(path) >= 1 && (path[0] == '/' || path[0] == '\\') {
+		return true
+	}
+
+	// Windows absolute path, see https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
+	if len(path) >= 3 && path[1] == ':' && (path[2] == '/' || path[2] == '\\') {
+		return true
+	}
+
+	return false
+}
+
+func newFrame(module string, function string, file string, line int) Frame {
 	frame := Frame{
-		AbsPath:  abspath,
-		Filename: relpath,
-		Lineno:   f.Line,
-		Module:   pkg,
+		Lineno:   line,
+		Module:   module,
 		Function: function,
 	}
 
-	frame.InApp = isInAppFrame(frame)
+	switch {
+	case len(file) == 0:
+		frame.Filename = unknown
+		// Leave abspath as the empty string to be omitted when serializing event as JSON.
+	case isAbsPath(file):
+		frame.AbsPath = file
+		// TODO: in the general case, it is not trivial to come up with a
+		// "project relative" path with the data we have in run time.
+		// We shall not use filepath.Base because it creates ambiguous paths and
+		// affects the "Suspect Commits" feature.
+		// For now, leave relpath empty to be omitted when serializing the event
+		// as JSON. Improve this later.
+	default:
+		// f.File is a relative path. This may happen when the binary is built
+		// with the -trimpath flag.
+		frame.Filename = file
+		// Omit abspath when serializing the event as JSON.
+	}
+
+	setInAppFrame(&frame)
 
 	return frame
 }
@@ -245,24 +257,27 @@ func NewFrame(f runtime.Frame) Frame {
 // runtime.Frame.Function values.
 func splitQualifiedFunctionName(name string) (pkg string, fun string) {
 	pkg = packageName(name)
-	fun = strings.TrimPrefix(name, pkg+".")
+	if len(pkg) > 0 {
+		fun = name[len(pkg)+1:]
+	}
 	return
 }
 
-func extractFrames(pcs []uintptr) []Frame {
-	var frames = make([]Frame, 0, len(pcs))
+func extractFrames(pcs []uintptr) []runtime.Frame {
+	var frames = make([]runtime.Frame, 0, len(pcs))
 	callersFrames := runtime.CallersFrames(pcs)
 
 	for {
 		callerFrame, more := callersFrames.Next()
 
-		frames = append(frames, NewFrame(callerFrame))
+		frames = append(frames, callerFrame)
 
 		if !more {
 			break
 		}
 	}
 
+	// TODO don't append and reverse, put in the right place from the start.
 	// reverse
 	for i, j := 0, len(frames)-1; i < j; i, j = i+1, j-1 {
 		frames[i], frames[j] = frames[j], frames[i]
@@ -271,41 +286,60 @@ func extractFrames(pcs []uintptr) []Frame {
 	return frames
 }
 
-// filterFrames filters out stack frames that are not meant to be reported to
-// Sentry. Those are frames internal to the SDK or Go.
-func filterFrames(frames []Frame) []Frame {
+// createFrames creates Frame objects while filtering out frames that are not
+// meant to be reported to Sentry, those are frames internal to the SDK or Go.
+func createFrames(frames []runtime.Frame) []Frame {
 	if len(frames) == 0 {
 		return nil
 	}
 
-	// reuse
-	filteredFrames := frames[:0]
+	result := make([]Frame, 0, len(frames))
 
 	for _, frame := range frames {
-		// Skip Go internal frames.
-		if frame.Module == "runtime" || frame.Module == "testing" {
-			continue
+		function := frame.Function
+		var pkg string
+		if function != "" {
+			pkg, function = splitQualifiedFunctionName(function)
 		}
-		// Skip Sentry internal frames, except for frames in _test packages (for
-		// testing).
-		if strings.HasPrefix(frame.Module, "github.com/getsentry/sentry-go") &&
-			!strings.HasSuffix(frame.Module, "_test") {
-			continue
+
+		if !shouldSkipFrame(pkg) {
+			result = append(result, newFrame(pkg, function, frame.File, frame.Line))
 		}
-		filteredFrames = append(filteredFrames, frame)
 	}
 
-	return filteredFrames
+	return result
 }
 
-func isInAppFrame(frame Frame) bool {
-	if strings.HasPrefix(frame.AbsPath, build.Default.GOROOT) ||
-		strings.Contains(frame.Module, "vendor") ||
-		strings.Contains(frame.Module, "third_party") {
-		return false
+// TODO ID: why do we want to do this?
+// I'm not aware of other SDKs skipping all Sentry frames, regardless of their position in the stactrace.
+// For example, in the .NET SDK, only the first frames are skipped until the call to the SDK.
+// As is, this will also hide any intermediate frames in the stack and make debugging issues harder.
+func shouldSkipFrame(module string) bool {
+	// Skip Go internal frames.
+	if module == "runtime" || module == "testing" {
+		return true
 	}
 
-	return true
+	// Skip Sentry internal frames, except for frames in _test packages (for testing).
+	if strings.HasPrefix(module, "github.com/getsentry/sentry-go") &&
+		!strings.HasSuffix(module, "_test") {
+		return true
+	}
+
+	return false
+}
+
+// On Windows, GOROOT has backslashes, but we want forward slashes.
+var goRoot = strings.ReplaceAll(build.Default.GOROOT, "\\", "/")
+
+func setInAppFrame(frame *Frame) {
+	if strings.HasPrefix(frame.AbsPath, goRoot) ||
+		strings.Contains(frame.Module, "vendor") ||
+		strings.Contains(frame.Module, "third_party") {
+		frame.InApp = false
+	} else {
+		frame.InApp = true
+	}
 }
 
 func callerFunctionName() string {
@@ -321,9 +355,7 @@ func callerFunctionName() string {
 // It replicates https://golang.org/pkg/debug/gosym/#Sym.PackageName, avoiding a
 // dependency on debug/gosym.
 func packageName(name string) string {
-	// A prefix of "type." and "go." is a compiler-generated symbol that doesn't belong to any package.
-	// See variable reservedimports in cmd/compile/internal/gc/subr.go
-	if strings.HasPrefix(name, "go.") || strings.HasPrefix(name, "type.") {
+	if isCompilerGeneratedSymbol(name) {
 		return ""
 	}