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

2026-06-23 13:17:16 +02:00
parent 0227912325
commit 1adf50e3db
2436 changed files with 1078758 additions and 114 deletions
@@ -0,0 +1,261 @@
+package protocol
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// apiVersion is the version of the Sentry API.
+const apiVersion = "7"
+
+type scheme string
+
+const (
+	SchemeHTTP  scheme = "http"
+	SchemeHTTPS scheme = "https"
+)
+
+func (scheme scheme) defaultPort() int {
+	switch scheme {
+	case SchemeHTTPS:
+		return 443
+	case SchemeHTTP:
+		return 80
+	default:
+		return 80
+	}
+}
+
+// DsnParseError represents an error that occurs if a Sentry
+// DSN cannot be parsed.
+type DsnParseError struct {
+	Message string
+}
+
+func (e DsnParseError) Error() string {
+	return "[Sentry] DsnParseError: " + e.Message
+}
+
+// Dsn is used as the remote address source to client transport.
+type Dsn struct {
+	scheme    scheme
+	publicKey string
+	secretKey string
+	host      string
+	port      int
+	path      string
+	projectID string
+	orgID     uint64
+}
+
+// NewDsn creates a Dsn by parsing rawURL. Most users will never call this
+// function directly. It is provided for use in custom Transport
+// implementations.
+func NewDsn(rawURL string) (*Dsn, error) {
+	// Parse
+	parsedURL, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, &DsnParseError{fmt.Sprintf("invalid url: %v", err)}
+	}
+
+	// Scheme
+	var scheme scheme
+	switch parsedURL.Scheme {
+	case "http":
+		scheme = SchemeHTTP
+	case "https":
+		scheme = SchemeHTTPS
+	default:
+		return nil, &DsnParseError{"invalid scheme"}
+	}
+
+	// PublicKey
+	publicKey := parsedURL.User.Username()
+	if publicKey == "" {
+		return nil, &DsnParseError{"empty username"}
+	}
+
+	// SecretKey
+	var secretKey string
+	if parsedSecretKey, ok := parsedURL.User.Password(); ok {
+		secretKey = parsedSecretKey
+	}
+
+	// Host
+	host := parsedURL.Hostname()
+	if host == "" {
+		return nil, &DsnParseError{"empty host"}
+	}
+
+	// OrgID (optional)
+	var orgID uint64
+	parts := strings.Split(host, ".")
+	orgPart := parts[0]
+	if len(orgPart) >= 2 && orgPart[0] == 'o' {
+		parsedOrgID, err := strconv.ParseUint(orgPart[1:], 10, 64)
+		if err == nil {
+			orgID = parsedOrgID
+		}
+	}
+
+	// Port
+	var port int
+	if p := parsedURL.Port(); p != "" {
+		port, err = strconv.Atoi(p)
+		if err != nil {
+			return nil, &DsnParseError{"invalid port"}
+		}
+	} else {
+		port = scheme.defaultPort()
+	}
+
+	// ProjectID
+	if parsedURL.Path == "" || parsedURL.Path == "/" {
+		return nil, &DsnParseError{"empty project id"}
+	}
+	pathSegments := strings.Split(parsedURL.Path[1:], "/")
+	projectID := pathSegments[len(pathSegments)-1]
+
+	if projectID == "" {
+		return nil, &DsnParseError{"empty project id"}
+	}
+
+	// Path
+	var path string
+	if len(pathSegments) > 1 {
+		path = "/" + strings.Join(pathSegments[0:len(pathSegments)-1], "/")
+	}
+
+	return &Dsn{
+		scheme:    scheme,
+		publicKey: publicKey,
+		secretKey: secretKey,
+		host:      host,
+		port:      port,
+		path:      path,
+		projectID: projectID,
+		orgID:     orgID,
+	}, nil
+}
+
+// String formats Dsn struct into a valid string url.
+func (dsn Dsn) String() string {
+	var url string
+	url += fmt.Sprintf("%s://%s", dsn.scheme, dsn.publicKey)
+	if dsn.secretKey != "" {
+		url += fmt.Sprintf(":%s", dsn.secretKey)
+	}
+	url += fmt.Sprintf("@%s", dsn.host)
+	if dsn.port != dsn.scheme.defaultPort() {
+		url += fmt.Sprintf(":%d", dsn.port)
+	}
+	if dsn.path != "" {
+		url += dsn.path
+	}
+	url += fmt.Sprintf("/%s", dsn.projectID)
+	return url
+}
+
+// Get the scheme of the DSN.
+func (dsn Dsn) GetScheme() string {
+	return string(dsn.scheme)
+}
+
+// Get the public key of the DSN.
+func (dsn Dsn) GetPublicKey() string {
+	return dsn.publicKey
+}
+
+// Get the secret key of the DSN.
+func (dsn Dsn) GetSecretKey() string {
+	return dsn.secretKey
+}
+
+// Get the host of the DSN.
+func (dsn Dsn) GetHost() string {
+	return dsn.host
+}
+
+// Get the port of the DSN.
+func (dsn Dsn) GetPort() int {
+	return dsn.port
+}
+
+// Get the path of the DSN.
+func (dsn Dsn) GetPath() string {
+	return dsn.path
+}
+
+// Get the project ID of the DSN.
+func (dsn Dsn) GetProjectID() string {
+	return dsn.projectID
+}
+
+// GetOrgID returns the orgID that was parsed from the DSN.
+func (dsn Dsn) GetOrgID() uint64 {
+	return dsn.orgID
+}
+
+// SetOrgID sets the orgID used for trace continuation.
+//
+// This function is used for overriding the orgID parsed from the DSN.
+func (dsn *Dsn) SetOrgID(orgID uint64) {
+	dsn.orgID = orgID
+}
+
+// GetAPIURL returns the URL of the envelope endpoint of the project
+// associated with the DSN.
+func (dsn Dsn) GetAPIURL() *url.URL {
+	var rawURL string
+	rawURL += fmt.Sprintf("%s://%s", dsn.scheme, dsn.host)
+	if dsn.port != dsn.scheme.defaultPort() {
+		rawURL += fmt.Sprintf(":%d", dsn.port)
+	}
+	if dsn.path != "" {
+		rawURL += dsn.path
+	}
+	rawURL += fmt.Sprintf("/api/%s/%s/", dsn.projectID, "envelope")
+	parsedURL, _ := url.Parse(rawURL)
+	return parsedURL
+}
+
+// RequestHeaders returns all the necessary headers that have to be used in the transport when sending events
+// to the /store endpoint.
+//
+// Deprecated: This method shall only be used if you want to implement your own transport that sends events to
+// the /store endpoint. If you're using the transport provided by the SDK, all necessary headers to authenticate
+// against the /envelope endpoint are added automatically.
+func (dsn Dsn) RequestHeaders(sdkVersion string) map[string]string {
+	auth := fmt.Sprintf("Sentry sentry_version=%s, sentry_timestamp=%d, "+
+		"sentry_client=sentry.go/%s, sentry_key=%s", apiVersion, time.Now().Unix(), sdkVersion, dsn.publicKey)
+
+	if dsn.secretKey != "" {
+		auth = fmt.Sprintf("%s, sentry_secret=%s", auth, dsn.secretKey)
+	}
+
+	return map[string]string{
+		"Content-Type":  "application/json",
+		"X-Sentry-Auth": auth,
+	}
+}
+
+// MarshalJSON converts the Dsn struct to JSON.
+func (dsn Dsn) MarshalJSON() ([]byte, error) {
+	return json.Marshal(dsn.String())
+}
+
+// UnmarshalJSON converts JSON data to the Dsn struct.
+func (dsn *Dsn) UnmarshalJSON(data []byte) error {
+	var str string
+	_ = json.Unmarshal(data, &str)
+	newDsn, err := NewDsn(str)
+	if err != nil {
+		return err
+	}
+	*dsn = *newDsn
+	return nil
+}
@@ -0,0 +1,254 @@
+package protocol
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+)
+
+// Envelope represents a Sentry envelope containing headers and items.
+type Envelope struct {
+	Header *EnvelopeHeader `json:"-"`
+	Items  []*EnvelopeItem `json:"-"`
+}
+
+// EnvelopeHeader represents the header of a Sentry envelope.
+type EnvelopeHeader struct {
+	// EventID is the unique identifier for this event
+	EventID string `json:"event_id"`
+
+	// SentAt is the timestamp when the event was sent from the SDK as string in RFC 3339 format.
+	// Used for clock drift correction of the event timestamp. The time zone must be UTC.
+	SentAt time.Time `json:"sent_at,omitzero"`
+
+	// Dsn can be used for self-authenticated envelopes.
+	// This means that the envelope has all the information necessary to be sent to sentry.
+	// In this case the full DSN must be stored in this key.
+	Dsn *Dsn `json:"dsn,omitempty"`
+
+	// Sdk carries the same payload as the sdk interface in the event payload but can be carried for all events.
+	// This means that SDK information can be carried for minidumps, session data and other submissions.
+	Sdk *SdkInfo `json:"sdk,omitempty"`
+
+	// Trace contains the [Dynamic Sampling Context](https://develop.sentry.dev/sdk/telemetry/traces/dynamic-sampling-context/)
+	Trace map[string]string `json:"trace,omitempty"`
+}
+
+// EnvelopeItemType represents the type of envelope item.
+type EnvelopeItemType string
+
+// Constants for envelope item types as defined in the Sentry documentation.
+const (
+	EnvelopeItemTypeEvent        EnvelopeItemType = "event"
+	EnvelopeItemTypeTransaction  EnvelopeItemType = "transaction"
+	EnvelopeItemTypeCheckIn      EnvelopeItemType = "check_in"
+	EnvelopeItemTypeAttachment   EnvelopeItemType = "attachment"
+	EnvelopeItemTypeLog          EnvelopeItemType = "log"
+	EnvelopeItemTypeTraceMetric  EnvelopeItemType = "trace_metric"
+	EnvelopeItemTypeClientReport EnvelopeItemType = "client_report"
+)
+
+// EnvelopeItemHeader represents the header of an envelope item.
+type EnvelopeItemHeader struct {
+	// Type specifies the type of this Item and its contents.
+	// Based on the Item type, more headers may be required.
+	Type EnvelopeItemType `json:"type"`
+
+	// Length is the length of the payload in bytes.
+	// If no length is specified, the payload implicitly goes to the next newline.
+	// For payloads containing newline characters, the length must be specified.
+	Length *int `json:"length,omitempty"`
+
+	// Filename is the name of the attachment file (used for attachments)
+	Filename string `json:"filename,omitempty"`
+
+	// ContentType is the MIME type of the item payload (used for attachments and some other item types)
+	ContentType string `json:"content_type,omitempty"`
+
+	// ItemCount is the number of items in a batch (used for logs)
+	ItemCount *int `json:"item_count,omitempty"`
+
+	// SpanCount is the number of spans in a transaction (used for client reports)
+	SpanCount int `json:"-"`
+}
+
+// EnvelopeItem represents a single item or batch within an envelope.
+type EnvelopeItem struct {
+	Header  *EnvelopeItemHeader `json:"-"`
+	Payload []byte              `json:"-"`
+}
+
+// NewEnvelope creates a new envelope with the given header.
+func NewEnvelope(header *EnvelopeHeader) *Envelope {
+	return &Envelope{
+		Header: header,
+		Items:  make([]*EnvelopeItem, 0),
+	}
+}
+
+// AddItem adds an item to the envelope.
+func (e *Envelope) AddItem(item *EnvelopeItem) {
+	if item == nil {
+		return
+	}
+	e.Items = append(e.Items, item)
+}
+
+// Serialize serializes the envelope to the Sentry envelope format.
+//
+// Format: Headers "\n" { Item } [ "\n" ]
+// Item: Headers "\n" Payload "\n".
+func (e *Envelope) Serialize() ([]byte, error) {
+	var buf bytes.Buffer
+
+	headerBytes, err := json.Marshal(e.Header)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal envelope header: %w", err)
+	}
+
+	if _, err := buf.Write(headerBytes); err != nil {
+		return nil, fmt.Errorf("failed to write envelope header: %w", err)
+	}
+
+	if _, err := buf.WriteString("\n"); err != nil {
+		return nil, fmt.Errorf("failed to write newline after envelope header: %w", err)
+	}
+
+	for _, item := range e.Items {
+		if err := e.writeItem(&buf, item); err != nil {
+			return nil, fmt.Errorf("failed to write envelope item: %w", err)
+		}
+	}
+
+	return buf.Bytes(), nil
+}
+
+// WriteTo writes the envelope to the given writer in the Sentry envelope format.
+func (e *Envelope) WriteTo(w io.Writer) (int64, error) {
+	data, err := e.Serialize()
+	if err != nil {
+		return 0, err
+	}
+
+	n, err := w.Write(data)
+	return int64(n), err
+}
+
+// writeItem writes a single envelope item to the buffer.
+func (e *Envelope) writeItem(buf *bytes.Buffer, item *EnvelopeItem) error {
+	headerBytes, err := json.Marshal(item.Header)
+	if err != nil {
+		return fmt.Errorf("failed to marshal item header: %w", err)
+	}
+
+	if _, err := buf.Write(headerBytes); err != nil {
+		return fmt.Errorf("failed to write item header: %w", err)
+	}
+
+	if _, err := buf.WriteString("\n"); err != nil {
+		return fmt.Errorf("failed to write newline after item header: %w", err)
+	}
+
+	if len(item.Payload) > 0 {
+		if _, err := buf.Write(item.Payload); err != nil {
+			return fmt.Errorf("failed to write item payload: %w", err)
+		}
+	}
+
+	if _, err := buf.WriteString("\n"); err != nil {
+		return fmt.Errorf("failed to write newline after item payload: %w", err)
+	}
+
+	return nil
+}
+
+// Size returns the total size of the envelope when serialized.
+func (e *Envelope) Size() (int, error) {
+	data, err := e.Serialize()
+	if err != nil {
+		return 0, err
+	}
+	return len(data), nil
+}
+
+// NewEnvelopeItem creates a new envelope item with the specified type and payload.
+func NewEnvelopeItem(itemType EnvelopeItemType, payload []byte) *EnvelopeItem {
+	length := len(payload)
+	return &EnvelopeItem{
+		Header: &EnvelopeItemHeader{
+			Type:   itemType,
+			Length: &length,
+		},
+		Payload: payload,
+	}
+}
+
+// NewTransactionItem creates a new envelope item including the span count of the transaction.
+func NewTransactionItem(spanCount int, payload []byte) *EnvelopeItem {
+	length := len(payload)
+	return &EnvelopeItem{
+		Header: &EnvelopeItemHeader{
+			Type:      EnvelopeItemTypeTransaction,
+			Length:    &length,
+			SpanCount: spanCount,
+		},
+		Payload: payload,
+	}
+}
+
+// NewAttachmentItem creates a new envelope item for an attachment.
+// Parameters: filename, contentType, payload.
+func NewAttachmentItem(filename, contentType string, payload []byte) *EnvelopeItem {
+	length := len(payload)
+	return &EnvelopeItem{
+		Header: &EnvelopeItemHeader{
+			Type:        EnvelopeItemTypeAttachment,
+			Length:      &length,
+			ContentType: contentType,
+			Filename:    filename,
+		},
+		Payload: payload,
+	}
+}
+
+// NewLogItem creates a new envelope item for logs.
+func NewLogItem(itemCount int, payload []byte) *EnvelopeItem {
+	length := len(payload)
+	return &EnvelopeItem{
+		Header: &EnvelopeItemHeader{
+			Type:        EnvelopeItemTypeLog,
+			Length:      &length,
+			ItemCount:   &itemCount,
+			ContentType: "application/vnd.sentry.items.log+json",
+		},
+		Payload: payload,
+	}
+}
+
+// NewTraceMetricItem creates a new envelope item for trace metrics.
+func NewTraceMetricItem(itemCount int, payload []byte) *EnvelopeItem {
+	length := len(payload)
+	return &EnvelopeItem{
+		Header: &EnvelopeItemHeader{
+			Type:        EnvelopeItemTypeTraceMetric,
+			Length:      &length,
+			ItemCount:   &itemCount,
+			ContentType: "application/vnd.sentry.items.trace-metric+json",
+		},
+		Payload: payload,
+	}
+}
+
+// NewClientReportItem creates a new envelope item for client reports.
+func NewClientReportItem(payload []byte) *EnvelopeItem {
+	length := len(payload)
+	return &EnvelopeItem{
+		Header: &EnvelopeItemHeader{
+			Type:   EnvelopeItemTypeClientReport,
+			Length: &length,
+		},
+		Payload: payload,
+	}
+}
@@ -0,0 +1,68 @@
+package protocol
+
+import (
+	"context"
+	"time"
+
+	"github.com/getsentry/sentry-go/internal/ratelimit"
+)
+
+// TelemetryItem represents any telemetry data that can be stored in buffers and sent to Sentry.
+// This is the base interface that all telemetry items must implement.
+type TelemetryItem interface {
+	// GetCategory returns the rate limit category for this item.
+	GetCategory() ratelimit.Category
+
+	// GetEventID returns the event ID for this item.
+	GetEventID() string
+
+	// GetSdkInfo returns SDK information for the envelope header.
+	GetSdkInfo() *SdkInfo
+
+	// GetDynamicSamplingContext returns trace context for the envelope header.
+	GetDynamicSamplingContext() map[string]string
+
+	// MakeSerializationSafe prevents serialization races, by serializing user mutable data on the foreground.
+	// Should be used before passing telemetry to the processor.
+	MakeSerializationSafe()
+}
+
+// EnvelopeItemConvertible represents items that can be converted directly to envelope items.
+type EnvelopeItemConvertible interface {
+	TelemetryItem
+
+	// ToEnvelopeItem converts the item to a Sentry envelope item.
+	ToEnvelopeItem() (*EnvelopeItem, error)
+}
+
+// EnvelopeConvertible represents items that can convert themselves to complete envelopes.
+type EnvelopeConvertible interface {
+	TelemetryItem
+
+	// ToEnvelope converts the item to a Sentry envelope using the provided header.
+	ToEnvelope(*EnvelopeHeader) (*Envelope, error)
+}
+
+// TelemetryTransport represents the envelope-first transport interface.
+// This interface is designed for the telemetry buffer system and provides
+// non-blocking sends with backpressure signals.
+type TelemetryTransport interface {
+	// SendEnvelope sends an envelope to Sentry. Returns immediately with
+	// backpressure error if the queue is full.
+	SendEnvelope(envelope *Envelope) error
+
+	// HasCapacity reports whether the transport has capacity to accept at least one more envelope.
+	HasCapacity() bool
+
+	// IsRateLimited checks if a specific category is currently rate limited
+	IsRateLimited(category ratelimit.Category) bool
+
+	// Flush waits for all pending envelopes to be sent, with timeout
+	Flush(timeout time.Duration) bool
+
+	// FlushWithContext waits for all pending envelopes to be sent
+	FlushWithContext(ctx context.Context) bool
+
+	// Close shuts down the transport gracefully
+	Close()
+}
@@ -0,0 +1,49 @@
+package protocol
+
+import (
+	"encoding/json"
+
+	"github.com/getsentry/sentry-go/internal/ratelimit"
+)
+
+// LogAttribute is the JSON representation for a single log attribute value.
+type LogAttribute struct {
+	Value any    `json:"value"`
+	Type  string `json:"type"`
+}
+
+// Logs is a container for multiple log items which knows how to convert
+// itself into a single batched log envelope item.
+type Logs []TelemetryItem
+
+func (ls Logs) ToEnvelopeItem() (*EnvelopeItem, error) {
+	// Convert each log to its JSON representation
+	items := make([]json.RawMessage, 0, len(ls))
+	for _, log := range ls {
+		logPayload, err := json.Marshal(log)
+		if err != nil {
+			continue
+		}
+		items = append(items, logPayload)
+	}
+
+	if len(items) == 0 {
+		return nil, nil
+	}
+
+	wrapper := struct {
+		Items []json.RawMessage `json:"items"`
+	}{Items: items}
+
+	payload, err := json.Marshal(wrapper)
+	if err != nil {
+		return nil, err
+	}
+	return NewLogItem(len(ls), payload), nil
+}
+
+func (Logs) GetCategory() ratelimit.Category              { return ratelimit.CategoryLog }
+func (Logs) GetEventID() string                           { return "" }
+func (Logs) GetSdkInfo() *SdkInfo                         { return nil }
+func (Logs) GetDynamicSamplingContext() map[string]string { return nil }
+func (Logs) MakeSerializationSafe()                       {}
@@ -0,0 +1,42 @@
+package protocol
+
+import (
+	"encoding/json"
+
+	"github.com/getsentry/sentry-go/internal/ratelimit"
+)
+
+type Metrics []TelemetryItem
+
+func (ms Metrics) ToEnvelopeItem() (*EnvelopeItem, error) {
+	// Convert each metric to its JSON representation
+	items := make([]json.RawMessage, 0, len(ms))
+	for _, metric := range ms {
+		metricPayload, err := json.Marshal(metric)
+		if err != nil {
+			continue
+		}
+		items = append(items, metricPayload)
+	}
+
+	if len(items) == 0 {
+		return nil, nil
+	}
+
+	wrapper := struct {
+		Items []json.RawMessage `json:"items"`
+	}{Items: items}
+
+	payload, err := json.Marshal(wrapper)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTraceMetricItem(len(items), payload), nil
+}
+
+func (Metrics) GetCategory() ratelimit.Category              { return ratelimit.CategoryTraceMetric }
+func (Metrics) GetEventID() string                           { return "" }
+func (Metrics) GetSdkInfo() *SdkInfo                         { return nil }
+func (Metrics) GetDynamicSamplingContext() map[string]string { return nil }
+func (Metrics) MakeSerializationSafe()                       {}
@@ -0,0 +1,15 @@
+package protocol
+
+// SdkInfo contains SDK metadata.
+type SdkInfo struct {
+	Name         string       `json:"name,omitempty"`
+	Version      string       `json:"version,omitempty"`
+	Integrations []string     `json:"integrations,omitempty"`
+	Packages     []SdkPackage `json:"packages,omitempty"`
+}
+
+// SdkPackage describes a package that was installed.
+type SdkPackage struct {
+	Name    string `json:"name,omitempty"`
+	Version string `json:"version,omitempty"`
+}
@@ -0,0 +1,18 @@
+package protocol
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+)
+
+// GenerateEventID generates a random UUID v4 for use as a Sentry event ID.
+func GenerateEventID() string {
+	id := make([]byte, 16)
+	// Prefer rand.Read over rand.Reader, see https://go-review.googlesource.com/c/go/+/272326/.
+	_, _ = rand.Read(id)
+	id[6] &= 0x0F // clear version
+	id[6] |= 0x40 // set version to 4 (random uuid)
+	id[8] &= 0x3F // clear variant
+	id[8] |= 0x80 // set to IETF variant
+	return hex.EncodeToString(id)
+}