sentry

type Attachment struct {
	Filename    string
	ContentType string
	Payload     []byte
}

type BodyType string

type Breadcrumb struct {
	Type      string                 `json:"type,omitempty"`
	Category  string                 `json:"category,omitempty"`
	Message   string                 `json:"message,omitempty"`
	Data      map[string]interface{} `json:"data,omitempty"`
	Level     Level                  `json:"level,omitempty"`
	Timestamp time.Time              `json:"timestamp,omitzero"`
}

type BreadcrumbHint map[string]interface{}

type BreadcrumbOption func(*breadcrumbOptions)

type CaptureOption func(*captureOptions)

type CheckIn struct {
	// Check-In ID (unique and client generated)
	ID EventID `json:"check_in_id"`
	// The distinct slug of the monitor.
	MonitorSlug string `json:"monitor_slug"`
	// The status of the check-in.
	Status CheckInStatus `json:"status"`
	// The duration of the check-in. Will only take effect if the status is ok or error.
	Duration time.Duration `json:"duration,omitempty"`
}

type CheckInStatus string

type Client struct {

	// Transport is read-only. Replacing the transport of an existing client is
	// not supported, create a new client instead.
	Transport Transport
	// contains filtered or unexported fields
}

type ClientOptions struct {
	// The DSN to use. If the DSN is not set, the client is effectively
	// disabled.
	Dsn string
	// In debug mode, diagnostic information is written to DebugWriter, which
	// defaults to stderr.
	Debug bool
	// Configures whether SDK should generate and attach stacktraces to pure
	// capture message calls.
	AttachStacktrace bool
	// The sample rate for event submission in the range [0.0, 1.0]. By default,
	// all events are sent. Thus, as a historical special case, the sample rate
	// 0.0 is treated as if it was 1.0. To drop all events, set the DSN to the
	// empty string.
	SampleRate float64
	// Enable performance tracing.
	EnableTracing bool
	// The sample rate for sampling traces in the range [0.0, 1.0].
	TracesSampleRate float64
	// Used to customize the sampling of traces, overrides TracesSampleRate.
	TracesSampler TracesSampler
	// Control with URLs trace propagation should be enabled. Does not support regex patterns.
	TracePropagationTargets []string
	// PropagateTraceparent is used to control whether the W3C Trace Context HTTP traceparent header
	// is propagated on outgoing http requests.
	PropagateTraceparent bool
	// StrictTraceContinuation is used to control trace continuation from 3rd party services that happen to be
	// instrumented by Sentry.
	//
	// Enabling the option means that the SDK will require the org ids from baggage to match for continuing the trace.
	StrictTraceContinuation bool
	// OrgID configures the orgID used for trace propagation and features like StrictTraceContinuation.
	//
	// In most cases the orgID is already parsed from the DSN. This option should be used when non-standard Sentry DSNs
	// are used, such as self-hosted or when using a local Relay.
	OrgID uint64
	// List of regexp strings that will be used to match against event's message
	// and if applicable, caught errors type and value.
	// If the match is found, then a whole event will be dropped.
	IgnoreErrors []string
	// List of regexp strings that will be used to match against a transaction's
	// name.  If a match is found, then the transaction  will be dropped.
	IgnoreTransactions []string
	// Deprecated: Use DataCollection for granular control over what data the
	// SDK collects. When DataCollection is configured, SendDefaultPII is
	// ignored.
	//
	// If this flag is enabled, certain personally identifiable information (PII) is added by active integrations.
	// By default, no such data is sent.
	SendDefaultPII bool
	// DataCollection configures what data the SDK collects automatically. All fields are optional. By default
	// the SDK collects rich context for debugging while scrubbing sensitive values.
	//
	// See https://docs.sentry.io/platforms/go/configuration/options/#DataCollection
	DataCollection *DataCollection
	// BeforeSend is called before error events are sent to Sentry.
	// You can use it to mutate the event or return nil to discard it.
	BeforeSend func(event *Event, hint *EventHint) *Event
	// BeforeSendLong is called before log events are sent to Sentry.
	// You can use it to mutate the log event or return nil to discard it.
	BeforeSendLog func(event *Log) *Log
	// BeforeSendTransaction is called before transaction events are sent to Sentry.
	// Use it to mutate the transaction or return nil to discard the transaction.
	BeforeSendTransaction func(event *Event, hint *EventHint) *Event
	// Before breadcrumb add callback.
	BeforeBreadcrumb func(breadcrumb *Breadcrumb, hint *BreadcrumbHint) *Breadcrumb
	// BeforeSendMetric is called before metric events are sent to Sentry.
	// You can use it to mutate the metric or return nil to discard it.
	BeforeSendMetric func(metric *Metric) *Metric
	// Integrations to be installed on the current Client, receives default
	// integrations.
	Integrations func([]Integration) []Integration
	// io.Writer implementation that should be used with the Debug mode.
	DebugWriter io.Writer
	// The transport to use. Defaults to HTTPTransport.
	Transport Transport
	// The server name to be reported.
	ServerName string
	// The release to be sent with events.
	//
	// Some Sentry features are built around releases, and, thus, reporting
	// events with a non-empty release improves the product experience. See
	// https://docs.sentry.io/product/releases/.
	//
	// If Release is not set, the SDK will try to derive a default value
	// from environment variables or the Git repository in the working
	// directory.
	//
	// If you distribute a compiled binary, it is recommended to set the
	// Release value explicitly at build time. As an example, you can use:
	//
	// 	go build -ldflags='-X main.release=VALUE'
	//
	// That will set the value of a predeclared variable 'release' in the
	// 'main' package to 'VALUE'. Then, use that variable when initializing
	// the SDK:
	//
	// 	sentry.Init(ClientOptions{Release: release})
	//
	// See https://golang.org/cmd/go/ and https://golang.org/cmd/link/ for
	// the official documentation of -ldflags and -X, respectively.
	Release string
	// The dist to be sent with events.
	Dist string
	// The environment to be sent with events.
	Environment string
	// Maximum number of breadcrumbs
	// when MaxBreadcrumbs is negative then ignore breadcrumbs.
	MaxBreadcrumbs int
	// Maximum number of spans.
	//
	// See https://develop.sentry.dev/sdk/envelopes/#size-limits for size limits
	// applied during event ingestion. Events that exceed these limits might get dropped.
	MaxSpans int
	// An optional pointer to http.Client that will be used with a default
	// HTTPTransport. Using your own client will make HTTPTransport, HTTPProxy,
	// HTTPSProxy and CaCerts options ignored.
	HTTPClient *http.Client
	// An optional pointer to http.Transport that will be used with a default
	// HTTPTransport. Using your own transport will make HTTPProxy, HTTPSProxy
	// and CaCerts options ignored.
	HTTPTransport http.RoundTripper
	// An optional HTTP proxy to use.
	// This will default to the HTTP_PROXY environment variable.
	HTTPProxy string
	// An optional HTTPS proxy to use.
	// This will default to the HTTPS_PROXY environment variable.
	// HTTPS_PROXY takes precedence over HTTP_PROXY for https requests.
	HTTPSProxy string
	// An optional set of SSL certificates to use.
	CaCerts *x509.CertPool
	// MaxErrorDepth is the maximum number of errors reported in a chain of errors.
	// This protects the SDK from an arbitrarily long chain of wrapped errors.
	//
	// An additional consideration is that arguably reporting a long chain of errors
	// is of little use when debugging production errors with Sentry. The Sentry UI
	// is not optimized for long chains either. The top-level error together with a
	// stack trace is often the most useful information.
	MaxErrorDepth int
	// Default event tags. These are overridden by tags set on a scope.
	Tags map[string]string
	// DisableClientReports controls when client reports should be emitted.
	DisableClientReports bool
	// TraceIgnoreStatusCodes is a list of HTTP status codes that should not be traced.
	// Each element can be either:
	// - A single-element slice [code] for a specific status code
	// - A two-element slice [min, max] for a range of status codes (inclusive)
	// When an HTTP request results in a status code that matches any of these codes or ranges,
	// the transaction will not be sent to Sentry.
	//
	// Examples:
	//   [][]int{{404}}                           // ignore only status code 404
	//   [][]int{{400, 405}}                     // ignore status codes 400-405
	//   [][]int{{404}, {500}}                   // ignore status codes 404 and 500
	//   [][]int{{404}, {400, 405}, {500, 599}}  // ignore 404, range 400-405, and range 500-599
	//
	// By default, this ignores 404 status codes.
	//
	// IMPORTANT: to not ignore any status codes, the option should be an empty slice and not nil. The nil option is
	// used for defaulting to 404 ignores.
	TraceIgnoreStatusCodes [][]int
	// contains filtered or unexported fields
}

type CollectionMode int

type Context = map[string]interface{}

type DataCollection struct {
	// UserInfo controls automatic population of user.* fields from auto-instrumentation.
	//
	// This does NOT gate data explicitly set via Scope.SetUser(); that is
	// always attached. Defaults to true.
	UserInfo Option[bool]

	// Cookies configures collection of HTTP cookies.
	//
	// Defaults to using the built-in DenyList.
	Cookies *KeyValueCollectionBehavior

	// HTTPHeaders configures collection of HTTP request and response headers
	// independently.
	//
	// Defaults to both request and response using the built-in DenyList.
	HTTPHeaders *HeaderCollectionConfig

	// HTTPBodies controls which HTTP body types are collected.
	//
	// Defaults to collecting all valid body types.
	HTTPBodies []BodyType

	// QueryParams configures collection of URL query parameters.
	//
	// Defaults to using the built-in DenyList.
	QueryParams *KeyValueCollectionBehavior
	// contains filtered or unexported fields
}

type DebugMeta struct {
	SdkInfo *DebugMetaSdkInfo `json:"sdk_info,omitempty"`
	Images  []DebugMetaImage  `json:"images,omitempty"`
}

type DebugMetaImage struct {
	Type        string `json:"type,omitempty"`         // all
	ImageAddr   string `json:"image_addr,omitempty"`   // macho,elf,pe
	ImageSize   int    `json:"image_size,omitempty"`   // macho,elf,pe
	DebugID     string `json:"debug_id,omitempty"`     // macho,elf,pe,wasm,sourcemap
	DebugFile   string `json:"debug_file,omitempty"`   // macho,elf,pe,wasm
	CodeID      string `json:"code_id,omitempty"`      // macho,elf,pe,wasm
	CodeFile    string `json:"code_file,omitempty"`    // macho,elf,pe,wasm,sourcemap
	ImageVmaddr string `json:"image_vmaddr,omitempty"` // macho,elf,pe
	Arch        string `json:"arch,omitempty"`         // macho,elf,pe
	UUID        string `json:"uuid,omitempty"`         // proguard
}

type DebugMetaSdkInfo struct {
	SdkName           string `json:"sdk_name,omitempty"`
	VersionMajor      int    `json:"version_major,omitempty"`
	VersionMinor      int    `json:"version_minor,omitempty"`
	VersionPatchlevel int    `json:"version_patchlevel,omitempty"`
}

type Dsn struct {
	protocol.Dsn
}

type DsnParseError = protocol.DsnParseError

type DynamicSamplingContext struct {
	Entries map[string]string
	Frozen  bool
}

type Event struct {
	Breadcrumbs []*Breadcrumb      `json:"breadcrumbs,omitempty"`
	Contexts    map[string]Context `json:"contexts,omitempty"`
	Dist        string             `json:"dist,omitempty"`
	Environment string             `json:"environment,omitempty"`
	EventID     EventID            `json:"event_id,omitempty"`
	Fingerprint []string           `json:"fingerprint,omitempty"`
	Level       Level              `json:"level,omitempty"`
	Message     string             `json:"message,omitempty"`
	Platform    string             `json:"platform,omitempty"`
	Release     string             `json:"release,omitempty"`
	Sdk         SdkInfo            `json:"sdk,omitempty"`
	ServerName  string             `json:"server_name,omitempty"`
	Threads     []Thread           `json:"threads,omitempty"`
	Tags        map[string]string  `json:"tags,omitempty"`
	Timestamp   time.Time          `json:"timestamp,omitzero"`
	Transaction string             `json:"transaction,omitempty"`
	User        User               `json:"user,omitempty"`
	Logger      string             `json:"logger,omitempty"`
	Modules     map[string]string  `json:"modules,omitempty"`
	Request     *Request           `json:"request,omitempty"`
	Exception   []Exception        `json:"exception,omitempty"`
	DebugMeta   *DebugMeta         `json:"debug_meta,omitempty"`
	Attachments []*Attachment      `json:"-"`

	Type            string           `json:"type,omitempty"`
	StartTime       time.Time        `json:"start_timestamp,omitzero"`
	Spans           []*Span          `json:"spans,omitempty"`
	TransactionInfo *TransactionInfo `json:"transaction_info,omitempty"`

	CheckIn       *CheckIn       `json:"check_in,omitempty"`
	MonitorConfig *MonitorConfig `json:"monitor_config,omitempty"`

	// The fields below are only relevant for logs
	Logs []Log `json:"-"`

	// The fields below are only relevant for metrics
	Metrics []Metric `json:"-"`
	// contains filtered or unexported fields
}

type EventHint struct {
	Data               interface{}
	EventID            string
	OriginalException  error
	RecoveredException interface{}
	Context            context.Context
	Request            *http.Request
	Response           *http.Response
}

type EventID string

type EventProcessor func(event *Event, hint *EventHint) *Event

type Exception struct {
	Type       string      `json:"type,omitempty"`  // used as the main issue title
	Value      string      `json:"value,omitempty"` // used as the main issue subtitle
	Module     string      `json:"module,omitempty"`
	ThreadID   uint64      `json:"thread_id,omitempty"`
	Stacktrace *Stacktrace `json:"stacktrace,omitempty"`
	Mechanism  *Mechanism  `json:"mechanism,omitempty"`
}

type Frame struct {
	Function string `json:"function,omitempty"`
	Symbol   string `json:"symbol,omitempty"`
	// Module is, despite the name, the Sentry protocol equivalent of a Go
	// package's import path.
	Module      string                 `json:"module,omitempty"`
	Filename    string                 `json:"filename,omitempty"`
	AbsPath     string                 `json:"abs_path,omitempty"`
	Lineno      int                    `json:"lineno,omitempty"`
	Colno       int                    `json:"colno,omitempty"`
	PreContext  []string               `json:"pre_context,omitempty"`
	ContextLine string                 `json:"context_line,omitempty"`
	PostContext []string               `json:"post_context,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
	// found.  For example, a Java JAR, a .NET Assembly, or a native
	// dynamic library.  They exists for completeness, allowing the
	// construction and reporting of custom event payloads.
	Package         string `json:"package,omitempty"`
	InstructionAddr string `json:"instruction_addr,omitempty"`
	AddrMode        string `json:"addr_mode,omitempty"`
	SymbolAddr      string `json:"symbol_addr,omitempty"`
	ImageAddr       string `json:"image_addr,omitempty"`
	Platform        string `json:"platform,omitempty"`
	StackStart      bool   `json:"stack_start,omitempty"`
}

type HTTPSyncTransport struct {
	Timeout time.Duration
	// contains filtered or unexported fields
}

type HTTPTransport struct {

	// Size of the transport buffer, in envelopes. Defaults to 1000.
	BufferSize int
	// HTTP Client request timeout. Defaults to 30 seconds.
	Timeout time.Duration
	// contains filtered or unexported fields
}

type HeaderCollectionConfig struct {
	// Request configures collection of HTTP request headers.
	Request *KeyValueCollectionBehavior
	// Response configures collection of HTTP response headers.
	Response *KeyValueCollectionBehavior
}

type Integration interface {
	Name() string
	SetupOnce(client *Client)
}

type KeyValueCollectionBehavior struct {
	// Mode controls the collection strategy.
	Mode CollectionMode
	// Terms is a list of additional terms used by the active mode.
	Terms []string
}

type Level string

type Log struct {
	Timestamp  time.Time                  `json:"timestamp,omitzero"`
	TraceID    TraceID                    `json:"trace_id"`
	SpanID     SpanID                     `json:"span_id,omitzero"`
	Level      LogLevel                   `json:"level"`
	Severity   int                        `json:"severity_number,omitempty"`
	Body       string                     `json:"body"`
	Attributes map[string]attribute.Value `json:"attributes,omitempty"`
	// contains filtered or unexported fields
}

type LogEntry interface {
	// WithCtx creates a new LogEntry with the specified context without overwriting the previous one.
	WithCtx(ctx context.Context) LogEntry
	// StringSlice adds a string slice attribute to the LogEntry.
	StringSlice(key string, value []string) LogEntry
	// String adds a string attribute to the LogEntry.
	String(key, value string) LogEntry
	// Int adds an int attribute to the LogEntry.
	Int(key string, value int) LogEntry
	// Int64Slice adds an int64 slice attribute to the LogEntry.
	Int64Slice(key string, value []int64) LogEntry
	// Int64 adds an int64 attribute to the LogEntry.
	Int64(key string, value int64) LogEntry
	// Float64Slice adds a float64 slice attribute to the LogEntry.
	Float64Slice(key string, value []float64) LogEntry
	// Float64 adds a float64 attribute to the LogEntry.
	Float64(key string, value float64) LogEntry
	// BoolSlice adds a bool slice attribute to the LogEntry.
	BoolSlice(key string, value []bool) LogEntry
	// Bool adds a bool attribute to the LogEntry.
	Bool(key string, value bool) LogEntry
	// Emit emits the LogEntry with the provided arguments.
	Emit(args ...interface{})
	// Emitf emits the LogEntry using a format string and arguments.
	Emitf(format string, args ...interface{})
}

type LogLevel string

type Logger interface {
	// Write implements the io.Writer interface using the context passed to NewLogger.
	Write(p []byte) (n int, err error)

	// SetAttributes allows attaching parameters to the logger using the attribute API.
	// These attributes will be included in all subsequent log entries.
	SetAttributes(...attribute.Builder)

	// Trace defines the [sentry.LogLevel] for the log entry.
	Trace() LogEntry
	// Debug defines the [sentry.LogLevel] for the log entry.
	Debug() LogEntry
	// Info defines the [sentry.LogLevel] for the log entry.
	Info() LogEntry
	// Warn defines the [sentry.LogLevel] for the log entry.
	Warn() LogEntry
	// Error defines the [sentry.LogLevel] for the log entry.
	Error() LogEntry
	// Fatal defines the [sentry.LogLevel] for the log entry.
	Fatal() LogEntry
	// Panic defines the [sentry.LogLevel] for the log entry.
	Panic() LogEntry
	// LFatal defines the [sentry.LogLevel] for the log entry. This only sets
	// the level to fatal, but does not panic or exit.
	LFatal() LogEntry
	// GetCtx returns the [context.Context] set on the logger.
	GetCtx() context.Context
}

type Mechanism struct {
	Type             string         `json:"type"`
	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"`
}

type Meter interface {
	// WithCtx returns a new Meter that uses the given context for trace/span association.
	WithCtx(ctx context.Context) Meter
	// SetAttributes allows attaching parameters to the meter using the attribute API.
	// These attributes will be included in all subsequent metrics.
	SetAttributes(attrs ...attribute.Builder)
	// Count records a count metric.
	Count(name string, count int64, opts ...MeterOption)
	// Gauge records a gauge metric.
	Gauge(name string, value float64, opts ...MeterOption)
	// Distribution records a distribution metric.
	Distribution(name string, sample float64, opts ...MeterOption)
}

type MeterOption func(*meterOptions)

type Metric struct {
	Timestamp  time.Time                  `json:"timestamp,omitzero"`
	TraceID    TraceID                    `json:"trace_id"`
	SpanID     SpanID                     `json:"span_id,omitzero"`
	Type       MetricType                 `json:"type"`
	Name       string                     `json:"name"`
	Value      MetricValue                `json:"value"`
	Unit       string                     `json:"unit,omitempty"`
	Attributes map[string]attribute.Value `json:"attributes,omitempty"`
}

type MetricType string

type MetricValue struct {
	// contains filtered or unexported fields
}

type MockLogEntry struct {
	Attributes map[string]any
}

type MockTransport struct {
	// contains filtered or unexported fields
}

type MonitorConfig struct {
	Schedule MonitorSchedule `json:"schedule,omitempty"`
	// The allowed margin of minutes after the expected check-in time that
	// the monitor will not be considered missed for.
	CheckInMargin int64 `json:"checkin_margin,omitempty"`
	// The allowed duration in minutes that the monitor may be `in_progress`
	// for before being considered failed due to timeout.
	MaxRuntime int64 `json:"max_runtime,omitempty"`
	// 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 MonitorSchedule interface {
	// contains filtered or unexported methods
}

type MonitorScheduleUnit string

type NoopTransport struct{}

type Option[T any] struct {
	Value T
	IsSet bool
}

type PropagationContext struct {
	TraceID                TraceID                `json:"trace_id"`
	SpanID                 SpanID                 `json:"span_id"`
	ParentSpanID           SpanID                 `json:"parent_span_id,omitzero"`
	Sampled                Sampled                `json:"-"`
	DynamicSamplingContext DynamicSamplingContext `json:"-"`
}

type Request struct {
	URL         string            `json:"url,omitempty"`
	Method      string            `json:"method,omitempty"`
	Data        string            `json:"data,omitempty"`
	QueryString string            `json:"query_string,omitempty"`
	Cookies     string            `json:"cookies,omitempty"`
	Headers     map[string]string `json:"headers,omitempty"`
	Env         map[string]string `json:"env,omitempty"`
}

type SDKMetaData struct {
	// contains filtered or unexported fields
}

type Sampled int8

type SamplingContext struct {
	Span   *Span // The current span, always non-nil.
	Parent *Span // The local parent span, non-nil only when the parent exists in the same process.
	// ParentSampled is the sampling decision of the parent span.
	//
	// For a remote span, Parent is nil but ParentSampled reflects the upstream decision.
	// For a local span, ParentSampled mirrors Parent.Sampled.
	ParentSampled Sampled
	// ParentSampleRate is the sample rate used by the parent transaction.
	ParentSampleRate *float64
}

type Scope struct {
	// contains filtered or unexported fields
}

type SdkInfo = protocol.SdkInfo

type SdkPackage = protocol.SdkPackage

type Span struct {
	TraceID      TraceID                `json:"trace_id"`
	SpanID       SpanID                 `json:"span_id"`
	ParentSpanID SpanID                 `json:"parent_span_id,omitzero"`
	Name         string                 `json:"name,omitempty"`
	Op           string                 `json:"op,omitempty"`
	Description  string                 `json:"description,omitempty"`
	Status       SpanStatus             `json:"status,omitempty"`
	Tags         map[string]string      `json:"tags,omitempty"`
	StartTime    time.Time              `json:"start_timestamp,omitzero"`
	EndTime      time.Time              `json:"timestamp,omitzero"`
	Data         map[string]interface{} `json:"data,omitempty"`
	Sampled      Sampled                `json:"-"`
	Source       TransactionSource      `json:"-"`
	Origin       SpanOrigin             `json:"origin,omitempty"`
	// contains filtered or unexported fields
}

type SpanID [8]byte

type SpanOption func(s *Span)

type SpanOrigin string

type SpanStatus uint8

type Stacktrace struct {
	Frames        []Frame `json:"frames,omitempty"`
	FramesOmitted []uint  `json:"frames_omitted,omitempty"`
}

type Thread struct {
	ID         string      `json:"id,omitempty"`
	Name       string      `json:"name,omitempty"`
	Stacktrace *Stacktrace `json:"stacktrace,omitempty"`
	Crashed    bool        `json:"crashed,omitempty"`
	Current    bool        `json:"current,omitempty"`
}

type TraceContext struct {
	TraceID      TraceID                `json:"trace_id"`
	SpanID       SpanID                 `json:"span_id"`
	ParentSpanID SpanID                 `json:"parent_span_id,omitzero"`
	Op           string                 `json:"op,omitempty"`
	Description  string                 `json:"description,omitempty"`
	Status       SpanStatus             `json:"status,omitempty"`
	Data         map[string]interface{} `json:"data,omitempty"`
}

type TraceID [16]byte

type TraceParentContext struct {
	TraceID      TraceID
	ParentSpanID SpanID
	Sampled      Sampled
}

type TracesSampler func(ctx SamplingContext) float64

type TransactionInfo struct {
	Source TransactionSource `json:"source,omitempty"`
}

type TransactionSource string

type Transport interface {
	// Configure initializes the transport before use. NewClient calls it once
	// with resolved options; wrappers must forward it to their transport.
	Configure(options ClientOptions)
	// SendEnvelope returns an error only when rejecting an envelope. The caller
	// records rejected items; built-in transports record losses after acceptance.
	// A nil error does not guarantee delivery. Implementations must return
	// promptly once ctx is done.
	SendEnvelope(ctx context.Context, envelope *protocol.Envelope) error
	// FlushWithContext waits for pending delivery attempts until ctx is canceled.
	// It must return false if ctx is done before they complete, including
	// attempts that SendEnvelope made inline with the same ctx.
	FlushWithContext(ctx context.Context) bool
	// Close releases transport resources.
	Close()
}

type User struct {
	ID        string            `json:"id,omitempty"`
	Email     string            `json:"email,omitempty"`
	IPAddress string            `json:"ip_address,omitempty"`
	Username  string            `json:"username,omitempty"`
	Name      string            `json:"name,omitempty"`
	Data      map[string]string `json:"data,omitempty"`
}