fix auth; update deps

vendor/github.com/getsentry/sentry-go/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.28.1
+
+The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.28.1.
+
+### Bug Fixes
+
+- Implement `http.ResponseWriter` to hook into various parts of the response process ([#837](https://github.com/getsentry/sentry-go/pull/837))
+
+## 0.28.0
+
+The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.28.0.
+
+### Features
+
+- Add a `Fiber` performance tracing & error reporting integration ([#795](https://github.com/getsentry/sentry-go/pull/795))
+- Add performance tracing to the `Echo` integration ([#722](https://github.com/getsentry/sentry-go/pull/722))
+- Add performance tracing to the `FastHTTP` integration ([#732](https://github.com/getsentry/sentry-go/pull/723))
+- Add performance tracing to the `Iris` integration ([#809](https://github.com/getsentry/sentry-go/pull/809))
+- Add performance tracing to the `Negroni` integration ([#808](https://github.com/getsentry/sentry-go/pull/808))
+- Add `FailureIssueThreshold` & `RecoveryThreshold` to `MonitorConfig` ([#775](https://github.com/getsentry/sentry-go/pull/775))
+- Use `errors.Unwrap()` to create exception groups ([#792](https://github.com/getsentry/sentry-go/pull/792))
+- Add support for matching on strings for `ClientOptions.IgnoreErrors` & `ClientOptions.IgnoreTransactions` ([#819](https://github.com/getsentry/sentry-go/pull/819))
+- Add `http.request.method` attribute for performance span data ([#786](https://github.com/getsentry/sentry-go/pull/786))
+- Accept `interface{}` for span data values ([#784](https://github.com/getsentry/sentry-go/pull/784))
+
+### Bug Fixes
+
+- Fix missing stack trace for parsing error in `logrusentry` ([#689](https://github.com/getsentry/sentry-go/pull/689))
+
 ## 0.27.0
 
 The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.27.0.

vendor/github.com/getsentry/sentry-go/README.md

@@ -13,7 +13,6 @@
 [![Build Status](https://github.com/getsentry/sentry-go/workflows/go-workflow/badge.svg)](https://github.com/getsentry/sentry-go/actions?query=workflow%3Ago-workflow)
 [![Go Report Card](https://goreportcard.com/badge/github.com/getsentry/sentry-go)](https://goreportcard.com/report/github.com/getsentry/sentry-go)
 [![Discord](https://img.shields.io/discord/621778831602221064)](https://discord.gg/Ww9hbqr)
-[![GoDoc](https://godoc.org/github.com/getsentry/sentry-go?status.svg)](https://godoc.org/github.com/getsentry/sentry-go)
 [![go.dev](https://img.shields.io/badge/go.dev-pkg-007d9c.svg?style=flat)](https://pkg.go.dev/github.com/getsentry/sentry-go)
 
 `sentry-go` provides a Sentry client implementation for the Go programming
@@ -85,7 +84,6 @@ checkout the official documentation:
 
 - [Bug Tracker](https://github.com/getsentry/sentry-go/issues)
 - [GitHub Project](https://github.com/getsentry/sentry-go)
-- [![GoDoc](https://godoc.org/github.com/getsentry/sentry-go?status.svg)](https://godoc.org/github.com/getsentry/sentry-go)
 - [![go.dev](https://img.shields.io/badge/go.dev-pkg-007d9c.svg?style=flat)](https://pkg.go.dev/github.com/getsentry/sentry-go)
 - [![Documentation](https://img.shields.io/badge/documentation-sentry.io-green.svg)](https://docs.sentry.io/platforms/go/)
 - [![Discussions](https://img.shields.io/github/discussions/getsentry/sentry-go.svg)](https://github.com/getsentry/sentry-go/discussions)

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

@@ -87,6 +87,10 @@ type MonitorConfig struct { //nolint: maligned // prefer readability over optima
 	// A tz database string representing the timezone which the monitor's execution schedule is in.
 	// See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
 	Timezone string `json:"timezone,omitempty"`
+	// The number of consecutive failed check-ins it takes before an issue is created.
+	FailureIssueThreshold int64 `json:"failure_issue_threshold,omitempty"`
+	// The number of consecutive OK check-ins it takes before an issue is resolved.
+	RecoveryThreshold int64 `json:"recovery_threshold,omitempty"`
 }
 
 type CheckIn struct { //nolint: maligned // prefer readability over optimal memory layout

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

@@ -90,11 +90,10 @@ func NewDsn(rawURL string) (*Dsn, error) {
 	// Port
 	var port int
 	if parsedURL.Port() != "" {
-		parsedPort, err := strconv.Atoi(parsedURL.Port())
+		port, err = strconv.Atoi(parsedURL.Port())
 		if err != nil {
 			return nil, &DsnParseError{"invalid port"}
 		}
-		port = parsedPort
 	} else {
 		port = scheme.defaultPort()
 	}

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

@@ -140,7 +140,7 @@ func (iei *ignoreErrorsIntegration) processor(event *Event, _ *EventHint) *Event
 
 	for _, suspect := range suspects {
 		for _, pattern := range iei.ignoreErrors {
-			if pattern.Match([]byte(suspect)) {
+			if pattern.Match([]byte(suspect)) || strings.Contains(suspect, pattern.String()) {
 				Logger.Printf("Event dropped due to being matched by `IgnoreErrors` option."+
 					"| Value matched: %s | Filter used: %s", suspect, pattern)
 				return nil
@@ -202,7 +202,7 @@ func (iei *ignoreTransactionsIntegration) processor(event *Event, _ *EventHint)
 	}
 
 	for _, pattern := range iei.ignoreTransactions {
-		if pattern.Match([]byte(suspect)) {
+		if pattern.Match([]byte(suspect)) || strings.Contains(suspect, pattern.String()) {
 			Logger.Printf("Transaction dropped due to being matched by `IgnoreTransactions` option."+
 				"| Value matched: %s | Filter used: %s", suspect, pattern)
 			return nil

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

@@ -3,6 +3,7 @@ package sentry
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -24,6 +25,9 @@ const profileType = "profile"
 // checkInType is the type of a check in event.
 const checkInType = "check_in"
 
+// metricType is the type of a metric event.
+const metricType = "statsd"
+
 // Level marks the severity of the event.
 type Level string
 
@@ -36,15 +40,6 @@ const (
 	LevelFatal   Level = "fatal"
 )
 
-func getSensitiveHeaders() map[string]bool {
-	return map[string]bool{
-		"Authorization":   true,
-		"Cookie":          true,
-		"X-Forwarded-For": true,
-		"X-Real-Ip":       true,
-	}
-}
-
 // SdkInfo contains all metadata about about the SDK being used.
 type SdkInfo struct {
 	Name         string       `json:"name,omitempty"`
@@ -170,6 +165,13 @@ type Request struct {
 	Env         map[string]string `json:"env,omitempty"`
 }
 
+var sensitiveHeaders = map[string]struct{}{
+	"Authorization":   {},
+	"Cookie":          {},
+	"X-Forwarded-For": {},
+	"X-Real-Ip":       {},
+}
+
 // NewRequest returns a new Sentry Request from the given http.Request.
 //
 // NewRequest avoids operations that depend on network access. In particular, it
@@ -200,7 +202,6 @@ func NewRequest(r *http.Request) *Request {
 			env = map[string]string{"REMOTE_ADDR": addr, "REMOTE_PORT": port}
 		}
 	} else {
-		sensitiveHeaders := getSensitiveHeaders()
 		for k, v := range r.Header {
 			if _, ok := sensitiveHeaders[k]; !ok {
 				headers[k] = strings.Join(v, ",")
@@ -222,11 +223,15 @@ func NewRequest(r *http.Request) *Request {
 
 // Mechanism is the mechanism by which an exception was generated and handled.
 type Mechanism struct {
-	Type        string                 `json:"type,omitempty"`
-	Description string                 `json:"description,omitempty"`
-	HelpLink    string                 `json:"help_link,omitempty"`
-	Handled     *bool                  `json:"handled,omitempty"`
-	Data        map[string]interface{} `json:"data,omitempty"`
+	Type             string         `json:"type,omitempty"`
+	Description      string         `json:"description,omitempty"`
+	HelpLink         string         `json:"help_link,omitempty"`
+	Source           string         `json:"source,omitempty"`
+	Handled          *bool          `json:"handled,omitempty"`
+	ParentID         *int           `json:"parent_id,omitempty"`
+	ExceptionID      int            `json:"exception_id"`
+	IsExceptionGroup bool           `json:"is_exception_group,omitempty"`
+	Data             map[string]any `json:"data,omitempty"`
 }
 
 // SetUnhandled indicates that the exception is an unhandled exception, i.e.
@@ -318,6 +323,7 @@ type Event struct {
 	Exception   []Exception            `json:"exception,omitempty"`
 	DebugMeta   *DebugMeta             `json:"debug_meta,omitempty"`
 	Attachments []*Attachment          `json:"-"`
+	Metrics     []Metric               `json:"-"`
 
 	// The fields below are only relevant for transactions.
 
@@ -339,27 +345,43 @@ type Event struct {
 // SetException appends the unwrapped errors to the event's exception list.
 //
 // maxErrorDepth is the maximum depth of the error chain we will look
-// into while unwrapping the errors.
+// into while unwrapping the errors. If maxErrorDepth is -1, we will
+// unwrap all errors in the chain.
 func (e *Event) SetException(exception error, maxErrorDepth int) {
-	err := exception
-	if err == nil {
+	if exception == nil {
 		return
 	}
 
-	for i := 0; i < maxErrorDepth && err != nil; i++ {
+	err := exception
+
+	for i := 0; err != nil && (i < maxErrorDepth || maxErrorDepth == -1); i++ {
+		// Add the current error to the exception slice with its details
 		e.Exception = append(e.Exception, Exception{
 			Value:      err.Error(),
 			Type:       reflect.TypeOf(err).String(),
 			Stacktrace: ExtractStacktrace(err),
 		})
-		switch previous := err.(type) {
-		case interface{ Unwrap() error }:
-			err = previous.Unwrap()
-		case interface{ Cause() error }:
-			err = previous.Cause()
-		default:
-			err = nil
+
+		// Attempt to unwrap the error using the standard library's Unwrap method.
+		// If errors.Unwrap returns nil, it means either there is no error to unwrap,
+		// or the error does not implement the Unwrap method.
+		unwrappedErr := errors.Unwrap(err)
+
+		if unwrappedErr != nil {
+			// The error was successfully unwrapped using the standard library's Unwrap method.
+			err = unwrappedErr
+			continue
 		}
+
+		cause, ok := err.(interface{ Cause() error })
+		if !ok {
+			// We cannot unwrap the error further.
+			break
+		}
+
+		// The error implements the Cause method, indicating it may have been wrapped
+		// using the github.com/pkg/errors package.
+		err = cause.Cause()
 	}
 
 	// Add a trace of the current stack to the most recent error in a chain if
@@ -370,8 +392,23 @@ func (e *Event) SetException(exception error, maxErrorDepth int) {
 		e.Exception[0].Stacktrace = NewStacktrace()
 	}
 
+	if len(e.Exception) <= 1 {
+		return
+	}
+
 	// event.Exception should be sorted such that the most recent error is last.
 	reverse(e.Exception)
+
+	for i := range e.Exception {
+		e.Exception[i].Mechanism = &Mechanism{
+			IsExceptionGroup: true,
+			ExceptionID:      i,
+		}
+		if i == 0 {
+			continue
+		}
+		e.Exception[i].Mechanism.ParentID = Pointer(i - 1)
+	}
 }
 
 // TODO: Event.Contexts map[string]interface{} => map[string]EventContext,
@@ -492,13 +529,12 @@ func (e *Event) checkInMarshalJSON() ([]byte, error) {
 
 // NewEvent creates a new Event.
 func NewEvent() *Event {
-	event := Event{
+	return &Event{
 		Contexts: make(map[string]Context),
 		Extra:    make(map[string]interface{}),
 		Tags:     make(map[string]string),
 		Modules:  make(map[string]string),
 	}
-	return &event
 }
 
 // Thread specifies threads that were running at the time of an event.

vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go

@@ -32,15 +32,14 @@ var knownCategories = map[Category]struct{}{
 
 // String returns the category formatted for debugging.
 func (c Category) String() string {
-	switch c {
-	case "":
+	if c == "" {
 		return "CategoryAll"
-	default:
-		caser := cases.Title(language.English)
-		rv := "Category"
-		for _, w := range strings.Fields(string(c)) {
-			rv += caser.String(w)
-		}
-		return rv
 	}
+
+	caser := cases.Title(language.English)
+	rv := "Category"
+	for _, w := range strings.Fields(string(c)) {
+		rv += caser.String(w)
+	}
+	return rv
 }

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

@@ -0,0 +1,427 @@
+package sentry
+
+import (
+	"fmt"
+	"hash/crc32"
+	"math"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+type (
+	NumberOrString interface {
+		int | string
+	}
+
+	void struct{}
+)
+
+var (
+	member     void
+	keyRegex   = regexp.MustCompile(`[^a-zA-Z0-9_/.-]+`)
+	valueRegex = regexp.MustCompile(`[^\w\d\s_:/@\.{}\[\]$-]+`)
+	unitRegex  = regexp.MustCompile(`[^a-z]+`)
+)
+
+type MetricUnit struct {
+	unit string
+}
+
+func (m MetricUnit) toString() string {
+	return m.unit
+}
+
+func NanoSecond() MetricUnit {
+	return MetricUnit{
+		"nanosecond",
+	}
+}
+
+func MicroSecond() MetricUnit {
+	return MetricUnit{
+		"microsecond",
+	}
+}
+
+func MilliSecond() MetricUnit {
+	return MetricUnit{
+		"millisecond",
+	}
+}
+
+func Second() MetricUnit {
+	return MetricUnit{
+		"second",
+	}
+}
+
+func Minute() MetricUnit {
+	return MetricUnit{
+		"minute",
+	}
+}
+
+func Hour() MetricUnit {
+	return MetricUnit{
+		"hour",
+	}
+}
+
+func Day() MetricUnit {
+	return MetricUnit{
+		"day",
+	}
+}
+
+func Week() MetricUnit {
+	return MetricUnit{
+		"week",
+	}
+}
+
+func Bit() MetricUnit {
+	return MetricUnit{
+		"bit",
+	}
+}
+
+func Byte() MetricUnit {
+	return MetricUnit{
+		"byte",
+	}
+}
+
+func KiloByte() MetricUnit {
+	return MetricUnit{
+		"kilobyte",
+	}
+}
+
+func KibiByte() MetricUnit {
+	return MetricUnit{
+		"kibibyte",
+	}
+}
+
+func MegaByte() MetricUnit {
+	return MetricUnit{
+		"megabyte",
+	}
+}
+
+func MebiByte() MetricUnit {
+	return MetricUnit{
+		"mebibyte",
+	}
+}
+
+func GigaByte() MetricUnit {
+	return MetricUnit{
+		"gigabyte",
+	}
+}
+
+func GibiByte() MetricUnit {
+	return MetricUnit{
+		"gibibyte",
+	}
+}
+
+func TeraByte() MetricUnit {
+	return MetricUnit{
+		"terabyte",
+	}
+}
+
+func TebiByte() MetricUnit {
+	return MetricUnit{
+		"tebibyte",
+	}
+}
+
+func PetaByte() MetricUnit {
+	return MetricUnit{
+		"petabyte",
+	}
+}
+
+func PebiByte() MetricUnit {
+	return MetricUnit{
+		"pebibyte",
+	}
+}
+
+func ExaByte() MetricUnit {
+	return MetricUnit{
+		"exabyte",
+	}
+}
+
+func ExbiByte() MetricUnit {
+	return MetricUnit{
+		"exbibyte",
+	}
+}
+
+func Ratio() MetricUnit {
+	return MetricUnit{
+		"ratio",
+	}
+}
+
+func Percent() MetricUnit {
+	return MetricUnit{
+		"percent",
+	}
+}
+
+func CustomUnit(unit string) MetricUnit {
+	return MetricUnit{
+		unitRegex.ReplaceAllString(unit, ""),
+	}
+}
+
+type Metric interface {
+	GetType() string
+	GetTags() map[string]string
+	GetKey() string
+	GetUnit() string
+	GetTimestamp() int64
+	SerializeValue() string
+	SerializeTags() string
+}
+
+type abstractMetric struct {
+	key  string
+	unit MetricUnit
+	tags map[string]string
+	// A unix timestamp (full seconds elapsed since 1970-01-01 00:00 UTC).
+	timestamp int64
+}
+
+func (am abstractMetric) GetTags() map[string]string {
+	return am.tags
+}
+
+func (am abstractMetric) GetKey() string {
+	return am.key
+}
+
+func (am abstractMetric) GetUnit() string {
+	return am.unit.toString()
+}
+
+func (am abstractMetric) GetTimestamp() int64 {
+	return am.timestamp
+}
+
+func (am abstractMetric) SerializeTags() string {
+	var sb strings.Builder
+
+	values := make([]string, 0, len(am.tags))
+	for k := range am.tags {
+		values = append(values, k)
+	}
+	sortSlice(values)
+
+	for _, key := range values {
+		val := sanitizeValue(am.tags[key])
+		key = sanitizeKey(key)
+		sb.WriteString(fmt.Sprintf("%s:%s,", key, val))
+	}
+	s := sb.String()
+	if len(s) > 0 {
+		s = s[:len(s)-1]
+	}
+	return s
+}
+
+// Counter Metric.
+type CounterMetric struct {
+	value float64
+	abstractMetric
+}
+
+func (c *CounterMetric) Add(value float64) {
+	c.value += value
+}
+
+func (c CounterMetric) GetType() string {
+	return "c"
+}
+
+func (c CounterMetric) SerializeValue() string {
+	return fmt.Sprintf(":%v", c.value)
+}
+
+// timestamp: A unix timestamp (full seconds elapsed since 1970-01-01 00:00 UTC).
+func NewCounterMetric(key string, unit MetricUnit, tags map[string]string, timestamp int64, value float64) CounterMetric {
+	am := abstractMetric{
+		key,
+		unit,
+		tags,
+		timestamp,
+	}
+
+	return CounterMetric{
+		value,
+		am,
+	}
+}
+
+// Distribution Metric.
+type DistributionMetric struct {
+	values []float64
+	abstractMetric
+}
+
+func (d *DistributionMetric) Add(value float64) {
+	d.values = append(d.values, value)
+}
+
+func (d DistributionMetric) GetType() string {
+	return "d"
+}
+
+func (d DistributionMetric) SerializeValue() string {
+	var sb strings.Builder
+	for _, el := range d.values {
+		sb.WriteString(fmt.Sprintf(":%v", el))
+	}
+	return sb.String()
+}
+
+// timestamp: A unix timestamp (full seconds elapsed since 1970-01-01 00:00 UTC).
+func NewDistributionMetric(key string, unit MetricUnit, tags map[string]string, timestamp int64, value float64) DistributionMetric {
+	am := abstractMetric{
+		key,
+		unit,
+		tags,
+		timestamp,
+	}
+
+	return DistributionMetric{
+		[]float64{value},
+		am,
+	}
+}
+
+// Gauge Metric.
+type GaugeMetric struct {
+	last  float64
+	min   float64
+	max   float64
+	sum   float64
+	count float64
+	abstractMetric
+}
+
+func (g *GaugeMetric) Add(value float64) {
+	g.last = value
+	g.min = math.Min(g.min, value)
+	g.max = math.Max(g.max, value)
+	g.sum += value
+	g.count++
+}
+
+func (g GaugeMetric) GetType() string {
+	return "g"
+}
+
+func (g GaugeMetric) SerializeValue() string {
+	return fmt.Sprintf(":%v:%v:%v:%v:%v", g.last, g.min, g.max, g.sum, g.count)
+}
+
+// timestamp: A unix timestamp (full seconds elapsed since 1970-01-01 00:00 UTC).
+func NewGaugeMetric(key string, unit MetricUnit, tags map[string]string, timestamp int64, value float64) GaugeMetric {
+	am := abstractMetric{
+		key,
+		unit,
+		tags,
+		timestamp,
+	}
+
+	return GaugeMetric{
+		value, // last
+		value, // min
+		value, // max
+		value, // sum
+		value, // count
+		am,
+	}
+}
+
+// Set Metric.
+type SetMetric[T NumberOrString] struct {
+	values map[T]void
+	abstractMetric
+}
+
+func (s *SetMetric[T]) Add(value T) {
+	s.values[value] = member
+}
+
+func (s SetMetric[T]) GetType() string {
+	return "s"
+}
+
+func (s SetMetric[T]) SerializeValue() string {
+	_hash := func(s string) uint32 {
+		return crc32.ChecksumIEEE([]byte(s))
+	}
+
+	values := make([]T, 0, len(s.values))
+	for k := range s.values {
+		values = append(values, k)
+	}
+	sortSlice(values)
+
+	var sb strings.Builder
+	for _, el := range values {
+		switch any(el).(type) {
+		case int:
+			sb.WriteString(fmt.Sprintf(":%v", el))
+		case string:
+			s := fmt.Sprintf("%v", el)
+			sb.WriteString(fmt.Sprintf(":%d", _hash(s)))
+		}
+	}
+
+	return sb.String()
+}
+
+// timestamp: A unix timestamp (full seconds elapsed since 1970-01-01 00:00 UTC).
+func NewSetMetric[T NumberOrString](key string, unit MetricUnit, tags map[string]string, timestamp int64, value T) SetMetric[T] {
+	am := abstractMetric{
+		key,
+		unit,
+		tags,
+		timestamp,
+	}
+
+	return SetMetric[T]{
+		map[T]void{
+			value: member,
+		},
+		am,
+	}
+}
+
+func sanitizeKey(s string) string {
+	return keyRegex.ReplaceAllString(s, "_")
+}
+
+func sanitizeValue(s string) string {
+	return valueRegex.ReplaceAllString(s, "")
+}
+
+type Ordered interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~string
+}
+
+func sortSlice[T Ordered](s []T) {
+	sort.Slice(s, func(i, j int) bool {
+		return s[i] < s[j]
+	})
+}

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

@@ -6,7 +6,7 @@ import (
 )
 
 // The version of the SDK.
-const SDKVersion = "0.27.0"
+const SDKVersion = "0.28.1"
 
 // apiVersion is the minimum version of the Sentry API compatible with the
 // sentry-go SDK.
@@ -72,18 +72,17 @@ func Recover() *EventID {
 
 // RecoverWithContext captures a panic and passes relevant context object.
 func RecoverWithContext(ctx context.Context) *EventID {
-	if err := recover(); err != nil {
-		var hub *Hub
-
-		if HasHubOnContext(ctx) {
-			hub = GetHubFromContext(ctx)
-		} else {
-			hub = CurrentHub()
-		}
-
-		return hub.RecoverWithContext(ctx, err)
+	err := recover()
+	if err == nil {
+		return nil
 	}
-	return nil
+
+	hub := GetHubFromContext(ctx)
+	if hub == nil {
+		hub = CurrentHub()
+	}
+
+	return hub.RecoverWithContext(ctx, err)
 }
 
 // WithScope is a shorthand for CurrentHub().WithScope.

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

@@ -7,8 +7,8 @@ import (
 
 // Checks whether the transaction should be profiled (according to ProfilesSampleRate)
 // and starts a profiler if so.
-func (span *Span) sampleTransactionProfile() {
-	var sampleRate = span.clientOptions().ProfilesSampleRate
+func (s *Span) sampleTransactionProfile() {
+	var sampleRate = s.clientOptions().ProfilesSampleRate
 	switch {
 	case sampleRate < 0.0 || sampleRate > 1.0:
 		Logger.Printf("Skipping transaction profiling: ProfilesSampleRate out of range [0.0, 1.0]: %f\n", sampleRate)
@@ -19,7 +19,7 @@ func (span *Span) sampleTransactionProfile() {
 		if globalProfiler == nil {
 			Logger.Println("Skipping transaction profiling: the profiler couldn't be started")
 		} else {
-			span.collectProfile = collectTransactionProfile
+			s.collectProfile = collectTransactionProfile
 		}
 	}
 }
@@ -69,22 +69,27 @@ func (info *profileInfo) UpdateFromEvent(event *Event) {
 	info.Dist = event.Dist
 	info.Transaction.ID = event.EventID
 
+	getStringFromContext := func(context map[string]interface{}, originalValue, key string) string {
+		v, ok := context[key]
+		if !ok {
+			return originalValue
+		}
+
+		if s, ok := v.(string); ok {
+			return s
+		}
+
+		return originalValue
+	}
+
 	if runtimeContext, ok := event.Contexts["runtime"]; ok {
-		if value, ok := runtimeContext["name"]; !ok {
-			info.Runtime.Name = value.(string)
-		}
-		if value, ok := runtimeContext["version"]; !ok {
-			info.Runtime.Version = value.(string)
-		}
+		info.Runtime.Name = getStringFromContext(runtimeContext, info.Runtime.Name, "name")
+		info.Runtime.Version = getStringFromContext(runtimeContext, info.Runtime.Version, "version")
 	}
 	if osContext, ok := event.Contexts["os"]; ok {
-		if value, ok := osContext["name"]; !ok {
-			info.OS.Name = value.(string)
-		}
+		info.OS.Name = getStringFromContext(osContext, info.OS.Name, "name")
 	}
 	if deviceContext, ok := event.Contexts["device"]; ok {
-		if value, ok := deviceContext["arch"]; !ok {
-			info.Device.Architecture = value.(string)
-		}
+		info.Device.Architecture = getStringFromContext(deviceContext, info.Device.Architecture, "arch")
 	}
 }

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

@@ -169,11 +169,11 @@ func StartSpan(ctx context.Context, operation string, options ...SpanOption) *Sp
 
 	span.Sampled = span.sample()
 
+	span.recorder = &spanRecorder{}
 	if hasParent {
 		span.recorder = parent.spanRecorder()
-	} else {
-		span.recorder = &spanRecorder{}
 	}
+
 	span.recorder.record(&span)
 
 	hub := hubFromContext(ctx)
@@ -226,7 +226,11 @@ func (s *Span) SetTag(name, value string) {
 // SetData sets a data on the span. It is recommended to use SetData instead of
 // accessing the data map directly as SetData takes care of initializing the map
 // when necessary.
-func (s *Span) SetData(name, value string) {
+func (s *Span) SetData(name string, value interface{}) {
+	if value == nil {
+		return
+	}
+
 	s.mu.Lock()
 	defer s.mu.Unlock()
 

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

@@ -2,6 +2,7 @@ package sentry
 
 import (
 	"bytes"
+	"context"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@@ -94,6 +95,55 @@ func getRequestBodyFromEvent(event *Event) []byte {
 	return nil
 }
 
+func marshalMetrics(metrics []Metric) []byte {
+	var b bytes.Buffer
+	for i, metric := range metrics {
+		b.WriteString(metric.GetKey())
+		if unit := metric.GetUnit(); unit != "" {
+			b.WriteString(fmt.Sprintf("@%s", unit))
+		}
+		b.WriteString(fmt.Sprintf("%s|%s", metric.SerializeValue(), metric.GetType()))
+		if serializedTags := metric.SerializeTags(); serializedTags != "" {
+			b.WriteString(fmt.Sprintf("|#%s", serializedTags))
+		}
+		b.WriteString(fmt.Sprintf("|T%d", metric.GetTimestamp()))
+
+		if i < len(metrics)-1 {
+			b.WriteString("\n")
+		}
+	}
+	return b.Bytes()
+}
+
+func encodeMetric(enc *json.Encoder, b io.Writer, metrics []Metric) error {
+	body := marshalMetrics(metrics)
+	// Item header
+	err := enc.Encode(struct {
+		Type   string `json:"type"`
+		Length int    `json:"length"`
+	}{
+		Type:   metricType,
+		Length: len(body),
+	})
+	if err != nil {
+		return err
+	}
+
+	// metric payload
+	if _, err = b.Write(body); err != nil {
+		return err
+	}
+
+	// "Envelopes should be terminated with a trailing newline."
+	//
+	// [1]: https://develop.sentry.dev/sdk/envelopes/#envelopes
+	if _, err := b.Write([]byte("\n")); err != nil {
+		return err
+	}
+
+	return err
+}
+
 func encodeAttachment(enc *json.Encoder, b io.Writer, attachment *Attachment) error {
 	// Attachment header
 	err := enc.Encode(struct {
@@ -175,11 +225,15 @@ func envelopeFromBody(event *Event, dsn *Dsn, sentAt time.Time, body json.RawMes
 		return nil, err
 	}
 
-	if event.Type == transactionType || event.Type == checkInType {
+	switch event.Type {
+	case transactionType, checkInType:
 		err = encodeEnvelopeItem(enc, event.Type, body)
-	} else {
+	case metricType:
+		err = encodeMetric(enc, &b, event.Metrics)
+	default:
 		err = encodeEnvelopeItem(enc, eventType, body)
 	}
+
 	if err != nil {
 		return nil, err
 	}
@@ -206,7 +260,7 @@ func envelopeFromBody(event *Event, dsn *Dsn, sentAt time.Time, body json.RawMes
 	return &b, nil
 }
 
-func getRequestFromEvent(event *Event, dsn *Dsn) (r *http.Request, err error) {
+func getRequestFromEvent(ctx context.Context, event *Event, dsn *Dsn) (r *http.Request, err error) {
 	defer func() {
 		if r != nil {
 			r.Header.Set("User-Agent", fmt.Sprintf("%s/%s", event.Sdk.Name, event.Sdk.Version))
@@ -233,7 +287,13 @@ func getRequestFromEvent(event *Event, dsn *Dsn) (r *http.Request, err error) {
 	if err != nil {
 		return nil, err
 	}
-	return http.NewRequest(
+
+	if ctx == nil {
+		ctx = context.Background()
+	}
+
+	return http.NewRequestWithContext(
+		ctx,
 		http.MethodPost,
 		dsn.GetAPIURL().String(),
 		envelope,
@@ -344,8 +404,13 @@ func (t *HTTPTransport) Configure(options ClientOptions) {
 	})
 }
 
-// SendEvent assembles a new packet out of Event and sends it to remote server.
+// SendEvent assembles a new packet out of Event and sends it to the remote server.
 func (t *HTTPTransport) SendEvent(event *Event) {
+	t.SendEventWithContext(context.Background(), event)
+}
+
+// SendEventWithContext assembles a new packet out of Event and sends it to the remote server.
+func (t *HTTPTransport) SendEventWithContext(ctx context.Context, event *Event) {
 	if t.dsn == nil {
 		return
 	}
@@ -356,7 +421,7 @@ func (t *HTTPTransport) SendEvent(event *Event) {
 		return
 	}
 
-	request, err := getRequestFromEvent(event, t.dsn)
+	request, err := getRequestFromEvent(ctx, event, t.dsn)
 	if err != nil {
 		return
 	}
@@ -478,6 +543,13 @@ func (t *HTTPTransport) worker() {
 				Logger.Printf("There was an issue with sending an event: %v", err)
 				continue
 			}
+			if response.StatusCode >= 400 && response.StatusCode <= 599 {
+				b, err := io.ReadAll(response.Body)
+				if err != nil {
+					Logger.Printf("Error while reading response code: %v", err)
+				}
+				Logger.Printf("Sending %s failed with the following error: %s", eventType, string(b))
+			}
 			t.mu.Lock()
 			t.limits.Merge(ratelimit.FromResponse(response))
 			t.mu.Unlock()
@@ -567,8 +639,13 @@ func (t *HTTPSyncTransport) Configure(options ClientOptions) {
 	}
 }
 
-// SendEvent assembles a new packet out of Event and sends it to remote server.
+// SendEvent assembles a new packet out of Event and sends it to the remote server.
 func (t *HTTPSyncTransport) SendEvent(event *Event) {
+	t.SendEventWithContext(context.Background(), event)
+}
+
+// SendEventWithContext assembles a new packet out of Event and sends it to the remote server.
+func (t *HTTPSyncTransport) SendEventWithContext(ctx context.Context, event *Event) {
 	if t.dsn == nil {
 		return
 	}
@@ -577,15 +654,18 @@ func (t *HTTPSyncTransport) SendEvent(event *Event) {
 		return
 	}
 
-	request, err := getRequestFromEvent(event, t.dsn)
+	request, err := getRequestFromEvent(ctx, event, t.dsn)
 	if err != nil {
 		return
 	}
 
 	var eventType string
-	if event.Type == transactionType {
+	switch {
+	case event.Type == transactionType:
 		eventType = "transaction"
-	} else {
+	case event.Type == metricType:
+		eventType = metricType
+	default:
 		eventType = fmt.Sprintf("%s event", event.Level)
 	}
 	Logger.Printf(
@@ -601,6 +681,14 @@ func (t *HTTPSyncTransport) SendEvent(event *Event) {
 		Logger.Printf("There was an issue with sending an event: %v", err)
 		return
 	}
+	if response.StatusCode >= 400 && response.StatusCode <= 599 {
+		b, err := io.ReadAll(response.Body)
+		if err != nil {
+			Logger.Printf("Error while reading response code: %v", err)
+		}
+		Logger.Printf("Sending %s failed with the following error: %s", eventType, string(b))
+	}
+
 	t.mu.Lock()
 	t.limits.Merge(ratelimit.FromResponse(response))
 	t.mu.Unlock()

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

@@ -112,3 +112,7 @@ func revisionFromBuildInfo(info *debug.BuildInfo) string {
 
 	return ""
 }
+
+func Pointer[T any](v T) *T {
+	return &v
+}