package sentry

import (

"context"

"encoding/json"

"errors"

"fmt"

"net"

"net/http"

"reflect"

"slices"

"strings"

"time"

)

// eventType is the type of an error event.

const eventType = "event"

// transactionType is the type of a transaction event.

const transactionType = "transaction"

// profileType is the type of a profile event.

// currently, profiles are always sent as part of a transaction event.

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

// Describes the severity of the event.

const (

LevelDebug Level = "debug"

LevelInfo Level = "info"

LevelWarning Level = "warning"

LevelError Level = "error"

LevelFatal Level = "fatal"

)

// SdkInfo contains all metadata about about the SDK being used.

type SdkInfo struct {

}

// SdkPackage describes a package that was installed.

type SdkPackage struct {

Name string `json:"name,omitempty"`

Version string `json:"version,omitempty"`

}

// TODO: This type could be more useful, as map of interface{} is too generic

// and requires a lot of type assertions in beforeBreadcrumb calls

// plus it could just be map[string]interface{} then.

// BreadcrumbHint contains information that can be associated with a Breadcrumb.

type BreadcrumbHint map[string]interface{}

// Breadcrumb specifies an application event that occurred before a Sentry event.

// An event may contain one or more breadcrumbs.

type Breadcrumb struct {

}

// TODO: provide constants for known breadcrumb types.

// See https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types.

// MarshalJSON converts the Breadcrumb struct to JSON.

func (b *Breadcrumb) MarshalJSON() ([]byte, error) {

}

// Attachment allows associating files with your events to aid in investigation.

// An event may contain one or more attachments.

type Attachment struct {

}

// User describes the user associated with an Event. If this is used, at least

// an ID or an IP address should be provided.

type User struct {

}

func (u User) IsEmpty() bool {

}

// Request contains information on a HTTP request related to the event.

type Request struct {

}

var sensitiveHeaders = map[string]struct{}{

"Authorization": {},

"Proxy-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

// does not read r.Body.

func NewRequest(r *http.Request) *Request {

}

// Mechanism is the mechanism by which an exception was generated and handled.

type Mechanism struct {

}

// SetUnhandled indicates that the exception is an unhandled exception, i.e.

// from a panic.

func (m *Mechanism) SetUnhandled() {

m.Handled = Pointer(false)

}

// Exception specifies an error that occurred.

type Exception struct {

}

// SDKMetaData is a struct to stash data which is needed at some point in the SDK's event processing pipeline

// but which shouldn't get send to Sentry.

type SDKMetaData struct {

dsc DynamicSamplingContext

transactionProfile *profileInfo

}

// Contains information about how the name of the transaction was determined.

type TransactionInfo struct {

Source TransactionSource `json:"source,omitempty"`

}

// The DebugMeta interface is not used in Golang apps, but may be populated

// when proxying Events from other platforms, like iOS, Android, and the

// Web. (See: https://develop.sentry.dev/sdk/event-payloads/debugmeta/ ).

type DebugMeta struct {

SdkInfo *DebugMetaSdkInfo `json:"sdk_info,omitempty"`

Images []DebugMetaImage `json:"images,omitempty"`

}

type DebugMetaSdkInfo struct {

}

type DebugMetaImage struct {

}

// EventID is a hexadecimal string representing a unique uuid4 for an Event.

// An EventID must be 32 characters long, lowercase and not have any dashes.

type EventID string

type Context = map[string]interface{}

// Event is the fundamental data structure that is sent to Sentry.

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. If maxErrorDepth is -1, we will

// unwrap all errors in the chain.

func (e *Event) SetException(exception error, maxErrorDepth int) {

}

// TODO: Event.Contexts map[string]interface{} => map[string]EventContext,

// to prevent accidentally storing T when we mean *T.

// For example, the TraceContext must be stored as *TraceContext to pick up the

// MarshalJSON method (and avoid copying).

// type EventContext interface{ EventContext() }

// MarshalJSON converts the Event struct to JSON.

func (e *Event) MarshalJSON() ([]byte, error) {

}

func (e *Event) defaultMarshalJSON() ([]byte, error) {

}

func (e *Event) transactionMarshalJSON() ([]byte, error) {

}

func (e *Event) checkInMarshalJSON() ([]byte, error) {

}

// NewEvent creates a new Event.

func NewEvent() *Event {

}

// Thread specifies threads that were running at the time of an event.

type Thread struct {

}

// EventHint contains information that can be associated with an Event.

type EventHint struct {

}