fix(go.sum): update ResolveSpec dependency to v1.0.87

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

@@ -0,0 +1,61 @@
+package attribute
+
+type Builder struct {
+	Key   string
+	Value Value
+}
+
+// String returns a Builder for a string value.
+func String(key, value string) Builder {
+	return Builder{key, StringValue(value)}
+}
+
+// Int64 returns a Builder for an int64.
+func Int64(key string, value int64) Builder {
+	return Builder{key, Int64Value(value)}
+}
+
+// Int returns a Builder for an int64.
+func Int(key string, value int) Builder {
+	return Builder{key, IntValue(value)}
+}
+
+// Float64 returns a Builder for a float64.
+func Float64(key string, v float64) Builder {
+	return Builder{key, Float64Value(v)}
+}
+
+// Bool returns a Builder for a boolean.
+func Bool(key string, v bool) Builder {
+	return Builder{key, BoolValue(v)}
+}
+
+// BoolSlice returns a Builder for a bool slice.
+func BoolSlice(key string, v []bool) Builder {
+	return Builder{key, BoolSliceValue(v)}
+}
+
+// IntSlice returns a Builder for an int slice.
+func IntSlice(key string, v []int) Builder {
+	return Builder{key, IntSliceValue(v)}
+}
+
+// Int64Slice returns a Builder for an int64 slice.
+func Int64Slice(key string, v []int64) Builder {
+	return Builder{key, Int64SliceValue(v)}
+}
+
+// Float64Slice returns a Builder for a float64 slice.
+func Float64Slice(key string, v []float64) Builder {
+	return Builder{key, Float64SliceValue(v)}
+}
+
+// StringSlice returns a Builder for a string slice.
+func StringSlice(key string, v []string) Builder {
+	return Builder{key, StringSliceValue(v)}
+}
+
+// Valid checks for valid key and type.
+func (b *Builder) Valid() bool {
+	return len(b.Key) > 0 && b.Value.Type() != INVALID
+}

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

@@ -0,0 +1,49 @@
+// Copied from https://github.com/open-telemetry/opentelemetry-go/blob/cc43e01c27892252aac9a8f20da28cdde957a289/attribute/rawhelpers.go
+// Copyright The OpenTelemetry Authors
+//
+// 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 attribute
+
+import (
+	"math"
+)
+
+func boolToRaw(b bool) uint64 { // b is not a control flag.
+	if b {
+		return 1
+	}
+	return 0
+}
+
+func rawToBool(r uint64) bool {
+	return r != 0
+}
+
+func int64ToRaw(i int64) uint64 {
+	// Assumes original was a valid int64 (overflow not checked).
+	return uint64(i) // nolint: gosec
+}
+
+func rawToInt64(r uint64) int64 {
+	// Assumes original was a valid int64 (overflow not checked).
+	return int64(r) // nolint: gosec
+}
+
+func float64ToRaw(f float64) uint64 {
+	return math.Float64bits(f)
+}
+
+func rawToFloat64(r uint64) float64 {
+	return math.Float64frombits(r)
+}

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

@@ -0,0 +1,15 @@
+package attribute
+
+import "reflect"
+
+func asSlice[T any](v any) []T {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Array {
+		return nil
+	}
+	cpy := make([]T, rv.Len())
+	if len(cpy) > 0 {
+		_ = reflect.Copy(reflect.ValueOf(cpy), rv)
+	}
+	return cpy
+}

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

@@ -0,0 +1,321 @@
+// Adapted from https://github.com/open-telemetry/opentelemetry-go/blob/cc43e01c27892252aac9a8f20da28cdde957a289/attribute/value.go
+//
+// Copyright The OpenTelemetry Authors
+//
+// 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 attribute
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+// Type describes the type of the data Value holds.
+type Type int // redefines builtin Type.
+
+// Value represents the value part in key-value pairs.
+type Value struct {
+	vtype    Type
+	numeric  uint64
+	stringly string
+	slice    any
+}
+
+const (
+	// INVALID is used for a Value with no value set.
+	INVALID Type = iota
+	// BOOL is a boolean Type Value.
+	BOOL
+	// INT64 is a 64-bit signed integral Type Value.
+	INT64
+	// FLOAT64 is a 64-bit floating point Type Value.
+	FLOAT64
+	// STRING is a string Type Value.
+	STRING
+	// BOOLSLICE is a slice of booleans Type Value.
+	BOOLSLICE
+	// INT64SLICE is a slice of 64-bit signed integral numbers Type Value.
+	INT64SLICE
+	// FLOAT64SLICE is a slice of 64-bit floating point numbers Type Value.
+	FLOAT64SLICE
+	// STRINGSLICE is a slice of strings Type Value.
+	STRINGSLICE
+	// UINT64 is a 64-bit unsigned integral Type Value.
+	//
+	// This type is intentionally not exposed through the Builder API.
+	UINT64
+)
+
+// BoolValue creates a BOOL Value.
+func BoolValue(v bool) Value {
+	return Value{
+		vtype:   BOOL,
+		numeric: boolToRaw(v),
+	}
+}
+
+// BoolSliceValue creates a BOOLSLICE Value.
+func BoolSliceValue(v []bool) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[bool]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: BOOLSLICE, slice: cp.Interface()}
+}
+
+// IntValue creates an INT64 Value.
+func IntValue(v int) Value {
+	return Int64Value(int64(v))
+}
+
+// IntSliceValue creates an INTSLICE Value.
+func IntSliceValue(v []int) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[int64]()))
+	for i, val := range v {
+		cp.Elem().Index(i).SetInt(int64(val))
+	}
+	return Value{
+		vtype: INT64SLICE,
+		slice: cp.Elem().Interface(),
+	}
+}
+
+// Int64Value creates an INT64 Value.
+func Int64Value(v int64) Value {
+	return Value{
+		vtype:   INT64,
+		numeric: int64ToRaw(v),
+	}
+}
+
+// Int64SliceValue creates an INT64SLICE Value.
+func Int64SliceValue(v []int64) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[int64]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: INT64SLICE, slice: cp.Interface()}
+}
+
+// Float64Value creates a FLOAT64 Value.
+func Float64Value(v float64) Value {
+	return Value{
+		vtype:   FLOAT64,
+		numeric: float64ToRaw(v),
+	}
+}
+
+// Float64SliceValue creates a FLOAT64SLICE Value.
+func Float64SliceValue(v []float64) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[float64]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: FLOAT64SLICE, slice: cp.Interface()}
+}
+
+// StringValue creates a STRING Value.
+func StringValue(v string) Value {
+	return Value{
+		vtype:    STRING,
+		stringly: v,
+	}
+}
+
+// StringSliceValue creates a STRINGSLICE Value.
+func StringSliceValue(v []string) Value {
+	cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[string]())).Elem()
+	reflect.Copy(cp, reflect.ValueOf(v))
+	return Value{vtype: STRINGSLICE, slice: cp.Interface()}
+}
+
+// Uint64Value creates a UINT64 Value.
+//
+// This constructor is intentionally not exposed through the Builder API.
+func Uint64Value(v uint64) Value {
+	return Value{
+		vtype:   UINT64,
+		numeric: v,
+	}
+}
+
+// Type returns a type of the Value.
+func (v Value) Type() Type {
+	return v.vtype
+}
+
+// AsBool returns the bool value. Make sure that the Value's type is
+// BOOL.
+func (v Value) AsBool() bool {
+	return rawToBool(v.numeric)
+}
+
+// AsBoolSlice returns the []bool value. Make sure that the Value's type is
+// BOOLSLICE.
+func (v Value) AsBoolSlice() []bool {
+	if v.vtype != BOOLSLICE {
+		return nil
+	}
+	return asSlice[bool](v.slice)
+}
+
+// AsInt64 returns the int64 value. Make sure that the Value's type is
+// INT64.
+func (v Value) AsInt64() int64 {
+	return rawToInt64(v.numeric)
+}
+
+// AsInt64Slice returns the []int64 value. Make sure that the Value's type is
+// INT64SLICE.
+func (v Value) AsInt64Slice() []int64 {
+	if v.vtype != INT64SLICE {
+		return nil
+	}
+	return asSlice[int64](v.slice)
+}
+
+// AsFloat64 returns the float64 value. Make sure that the Value's
+// type is FLOAT64.
+func (v Value) AsFloat64() float64 {
+	return rawToFloat64(v.numeric)
+}
+
+// AsFloat64Slice returns the []float64 value. Make sure that the Value's type is
+// FLOAT64SLICE.
+func (v Value) AsFloat64Slice() []float64 {
+	if v.vtype != FLOAT64SLICE {
+		return nil
+	}
+	return asSlice[float64](v.slice)
+}
+
+// AsString returns the string value. Make sure that the Value's type
+// is STRING.
+func (v Value) AsString() string {
+	return v.stringly
+}
+
+// AsStringSlice returns the []string value. Make sure that the Value's type is
+// STRINGSLICE.
+func (v Value) AsStringSlice() []string {
+	if v.vtype != STRINGSLICE {
+		return nil
+	}
+	return asSlice[string](v.slice)
+}
+
+// AsUint64 returns the uint64 value. Make sure that the Value's type is
+// UINT64.
+func (v Value) AsUint64() uint64 {
+	return v.numeric
+}
+
+type unknownValueType struct{}
+
+// AsInterface returns Value's data as interface{}.
+func (v Value) AsInterface() interface{} {
+	switch v.Type() {
+	case BOOL:
+		return v.AsBool()
+	case BOOLSLICE:
+		return v.AsBoolSlice()
+	case INT64:
+		return v.AsInt64()
+	case INT64SLICE:
+		return v.AsInt64Slice()
+	case FLOAT64:
+		return v.AsFloat64()
+	case FLOAT64SLICE:
+		return v.AsFloat64Slice()
+	case STRING:
+		return v.stringly
+	case STRINGSLICE:
+		return v.AsStringSlice()
+	case UINT64:
+		return v.numeric
+	}
+	return unknownValueType{}
+}
+
+// String returns a string representation of Value's data.
+func (v Value) String() string {
+	switch v.Type() {
+	case BOOLSLICE:
+		return fmt.Sprint(v.AsBoolSlice())
+	case BOOL:
+		return strconv.FormatBool(v.AsBool())
+	case INT64SLICE:
+		return fmt.Sprint(v.AsInt64Slice())
+	case INT64:
+		return strconv.FormatInt(v.AsInt64(), 10)
+	case FLOAT64SLICE:
+		return fmt.Sprint(v.AsFloat64Slice())
+	case FLOAT64:
+		return fmt.Sprint(v.AsFloat64())
+	case STRINGSLICE:
+		return fmt.Sprint(v.AsStringSlice())
+	case STRING:
+		return v.stringly
+	case UINT64:
+		return strconv.FormatUint(v.numeric, 10)
+	default:
+		return "unknown"
+	}
+}
+
+// MarshalJSON returns the JSON encoding of the Value.
+func (v Value) MarshalJSON() ([]byte, error) {
+	var jsonVal struct {
+		Value any    `json:"value"`
+		Type  string `json:"type"`
+	}
+	jsonVal.Type = mapTypesToStr[v.Type()]
+	jsonVal.Value = v.AsInterface()
+	return json.Marshal(jsonVal)
+}
+
+func (t Type) String() string {
+	switch t {
+	case BOOL:
+		return "bool"
+	case BOOLSLICE:
+		return "boolslice"
+	case INT64:
+		return "int64"
+	case INT64SLICE:
+		return "int64slice"
+	case FLOAT64:
+		return "float64"
+	case FLOAT64SLICE:
+		return "float64slice"
+	case STRING:
+		return "string"
+	case STRINGSLICE:
+		return "stringslice"
+	case UINT64:
+		return "uint64"
+	}
+	return "invalid"
+}
+
+// mapTypesToStr is a map from attribute.Type to the primitive types the server understands.
+// https://develop.sentry.dev/sdk/foundations/data-model/attributes/#primitive-types
+var mapTypesToStr = map[Type]string{
+	INVALID:      "",
+	BOOL:         "boolean",
+	INT64:        "integer",
+	FLOAT64:      "double",
+	STRING:       "string",
+	BOOLSLICE:    "array",
+	INT64SLICE:   "array",
+	FLOAT64SLICE: "array",
+	STRINGSLICE:  "array",
+	UINT64:       "integer", // wire format: same "integer" type
+}