errortracking

package
v0.0.0-...-ad5417f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 17, 2024 License: Apache-2.0, MIT Imports: 45 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	StoreEndpoint    string = "store"
	EnvelopeEndpoint string = "event"
	UnknownEndpoint  string = "unknown"
)
View Source 
const (
	IDTypeProject = "project"
	IDTypeGroup   = "organization"

	EndpointTypeWrite = "write"
	EndpointTypeRead  = "read"
)

Variables

This section is empty.

Functions

func ConfiguredCollectors 

func ConfiguredCollectors() []prometheus.Collector

func DisambiguateEventSource 

func DisambiguateEventSource(payload []byte) (string, interface{}, error)

func GenericHandlerRateLimited 

func GenericHandlerRateLimited(
	c ControllerInterface,
	rl RateLimiter,
	params interface{},
) middleware.Responder

GenericHandlerRateLimited wraps individual handlers to add rate limiting. Unfortunately, due to how go-openapi generates code, we need this DYI "middleware" to handle multiple different types in an uniform manner without too much copy-paste.

NOTE(prozlach): Unfortunately I was not able to use go-openapi's middleware:

  • there is no sane way to pass state to the middleware code just like e.g. Gin does with with its contexts.
  • passing RateLimiter as a field in the Controller struct is consistent with how we e.g. handle Queue.
  • we would need to parse/extract group/project ID for every request if we went with middleware as the request params are not available there

func GetRedis 

func GetRedis(
	redisAddr, redisPassword string,
	useRedisSentinel bool,
	redisConnectionPoolSize int,
) *redis.Client

func SetDeniedResponseHeaders 

func SetDeniedResponseHeaders(
	limitsData *redis_rate.Result, response RequestDeniedHeadersSetter, idType string,
)

func SetPermittedResponseHeaders 

func SetPermittedResponseHeaders(
	limitsData *redis_rate.Result, response RequestPermittedHeadersSetter,
)

Types

type BatchPackage 

type BatchPackage struct {
	Batch driver.Batch
	Count int64
}

func (*BatchPackage) Add 

func (b *BatchPackage) Add(data ...interface{}) error

type ClickhouseIngester 

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

func (*ClickhouseIngester) IngestEventData 

func (c *ClickhouseIngester) IngestEventData(
	ctx context.Context, projectID uint64, _ string, payload []byte, event *types.Event) error

func (*ClickhouseIngester) IngestMessageData 

func (c *ClickhouseIngester) IngestMessageData(
	ctx context.Context, projectID uint64, _ string, payload []byte, event *types.Event) error

func (*ClickhouseIngester) IngestSessionData 

func (c *ClickhouseIngester) IngestSessionData(
	ctx context.Context, projectID uint64, _ string, payload []byte, session *types.Session) error

type Controller 

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

func NewController 

func NewController(
	baseURL *url.URL,
	db Database,
	cloudDB Database,
	gatekeeperURL *url.URL,
	queue *persistentqueue.Queue,
	rateLimiter RateLimiter,
) *Controller

func (*Controller) DeleteProject 

func (c *Controller) DeleteProject(params projects.DeleteProjectParams) middleware.Responder

func (*Controller) DeleteProjectRateLimited 

func (c *Controller) DeleteProjectRateLimited(
	params projects.DeleteProjectParams,
) middleware.Responder

DeleteProjectRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) GetError 

func (c *Controller) GetError(params errors.GetErrorParams) middleware.Responder

func (*Controller) GetErrorRateLimited 

func (c *Controller) GetErrorRateLimited(
	params errors.GetErrorParams,
) middleware.Responder

GetErrorRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) GetStatsV2 

func (c *Controller) GetStatsV2(_ errors_v2.GetStatsV2Params) middleware.Responder

func (*Controller) ListErrors 

func (c *Controller) ListErrors(params errors.ListErrorsParams) middleware.Responder

func (*Controller) ListErrorsRateLimited 

func (c *Controller) ListErrorsRateLimited(
	params errors.ListErrorsParams,
) middleware.Responder

ListErrorsRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) ListEvents 

func (c *Controller) ListEvents(params errors.ListEventsParams) middleware.Responder

func (*Controller) ListEventsRateLimited 

func (c *Controller) ListEventsRateLimited(
	params errors.ListEventsParams,
) middleware.Responder

ListEventsRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) ListMessages 

func (c *Controller) ListMessages(params messages.ListMessagesParams) middleware.Responder

func (*Controller) ListMessagesRateLimited 

func (c *Controller) ListMessagesRateLimited(
	params messages.ListMessagesParams,
) middleware.Responder

ListMessagesRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) ListProjects 

func (c *Controller) ListProjects(params errors_v2.ListProjectsParams) middleware.Responder

ListProjects calls back the gatekeeper with the auth headers or user session so we can list GitLab projects.

func (*Controller) PostEnvelopeHandler 

func (c *Controller) PostEnvelopeHandler(
	params events.PostProjectsAPIProjectIDEnvelopeParams,
) middleware.Responder

PostEnvelopeHandler handles the POST request sent to the /projects/{projectID}/envelope route. Data model for Sentry envelope can have multiple item types: 

> See https://develop.sentry.dev/sdk/envelopes/#data-model

We currently accept the following item types: - event [https://develop.sentry.dev/sdk/envelopes/#event]

We do not yet support:

func (*Controller) PostEnvelopeHandlerRateLimited 

func (c *Controller) PostEnvelopeHandlerRateLimited(
	params events.PostProjectsAPIProjectIDEnvelopeParams,
) middleware.Responder

PostEnvelopeHandlerRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) PostStoreHandler 

func (c *Controller) PostStoreHandler(
	params events.PostProjectsAPIProjectIDStoreParams,
) middleware.Responder

func (*Controller) PostStoreHandlerRateLimited 

func (c *Controller) PostStoreHandlerRateLimited(
	params events.PostProjectsAPIProjectIDStoreParams,
) middleware.Responder

PostStoreHandlerRateLimited is just an adapter for GenericHandlerRateLimited.

func (*Controller) QueueProcessor 

func (c *Controller) QueueProcessor(buffer []interface{}) error

func (*Controller) UpdateError 

func (c *Controller) UpdateError(params errors.UpdateErrorParams) middleware.Responder

func (*Controller) UpdateErrorRateLimited 

func (c *Controller) UpdateErrorRateLimited(
	params errors.UpdateErrorParams,
) middleware.Responder

UpdateErrorRateLimited is just an adapter for GenericHandlerRateLimited.

type ControllerInterface 

type ControllerInterface interface {
	PostEnvelopeHandlerRateLimited(params events.PostProjectsAPIProjectIDEnvelopeParams) middleware.Responder
	PostEnvelopeHandler(params events.PostProjectsAPIProjectIDEnvelopeParams) middleware.Responder
	PostStoreHandlerRateLimited(params events.PostProjectsAPIProjectIDStoreParams) middleware.Responder
	PostStoreHandler(params events.PostProjectsAPIProjectIDStoreParams) middleware.Responder
	ListErrorsRateLimited(params errors.ListErrorsParams) middleware.Responder
	ListErrors(params errors.ListErrorsParams) middleware.Responder
	GetErrorRateLimited(params errors.GetErrorParams) middleware.Responder
	GetError(params errors.GetErrorParams) middleware.Responder
	UpdateErrorRateLimited(params errors.UpdateErrorParams) middleware.Responder
	UpdateError(params errors.UpdateErrorParams) middleware.Responder
	ListEventsRateLimited(params errors.ListEventsParams) middleware.Responder
	ListEvents(params errors.ListEventsParams) middleware.Responder
	DeleteProjectRateLimited(params projects.DeleteProjectParams) middleware.Responder
	DeleteProject(params projects.DeleteProjectParams) middleware.Responder
	ListProjects(params errors_v2.ListProjectsParams) middleware.Responder
	GetStatsV2(_ errors_v2.GetStatsV2Params) middleware.Responder
	ListMessagesRateLimited(params messages.ListMessagesParams) middleware.Responder
	ListMessages(params messages.ListMessagesParams) middleware.Responder
}

ControllerInterface ...

type Database 

type Database interface {
	GetConn() (*clickhouse.Conn, error)
	GetTZ() (*time.Location, error)

	InsertErrorTrackingErrorEvent(ctx context.Context, e *et.ErrorTrackingErrorEvent) error
	InsertErrorTrackingMessageEvent(ctx context.Context, e *et.ErrorTrackingMessageEvent) error
	InsertErrorTrackingSession(ctx context.Context, e *et.ErrorTrackingSession) error

	ListErrors(params errors.ListErrorsParams) ([]*models.Error, error)
	ListEvents(params errors.ListEventsParams) ([]*models.ErrorEvent, error)
	ListMessages(params messages.ListMessagesParams) ([]*models.MessageEvent, error)

	GetError(params errors.GetErrorParams) (*models.Error, error)
	UpdateError(params errors.UpdateErrorParams) (*models.Error, error)
	DeleteProject(params projects.DeleteProjectParams) error

	Close() error
}

func NewCloudDB 

func NewCloudDB(clickHouseDsn string, opts *DatabaseOptions) (Database, error)

func NewDB 

func NewDB(clickHouseDsn string, opts *DatabaseOptions) (Database, error)

NOTE: This clickhouse database initialization procedure should move to a new location so we can handle migrations.

type DatabaseOptions 

type DatabaseOptions struct {
	MaxOpenConns     int
	MaxIdleConns     int
	UseRemoteStorage string
	Debug            bool
}

type EventErrorHandler 

type EventErrorHandler struct{}

func (*EventErrorHandler) Handle 

func (e *EventErrorHandler) Handle(
	projectID uint64, item interface{}, payload []byte, b *EventsBatchPackage,
) error

type EventMessageHandler 

type EventMessageHandler struct{}

func (*EventMessageHandler) Handle 

func (me *EventMessageHandler) Handle(
	projectID uint64, item interface{}, payload []byte, b *EventsBatchPackage,
) error

type EventsBatchPackage 

type EventsBatchPackage struct {
	ErrorV1EventsBatch BatchPackage
	ErrorV1StatusBatch BatchPackage
	MessageEventsBatch BatchPackage
	SessionsBatch      BatchPackage
}

func (*EventsBatchPackage) Send 

func (ebp *EventsBatchPackage) Send()

type FrequencyPair 

type FrequencyPair [2]uint64

type ISentryEventHandler 

type ISentryEventHandler interface {
	Validate(e *types.Event) error
	InsertEvent(ctx context.Context, projectID uint64, payloadType string, e *types.Event, payload []byte) error
}

func GetEventManager 

func GetEventManager(dataItemType string, ingester Ingester) (ISentryEventHandler, error)

type Ingester 

type Ingester interface {
	IngestEventData(context.Context, uint64, string, []byte, *types.Event) error
	IngestMessageData(context.Context, uint64, string, []byte, *types.Event) error
	IngestSessionData(context.Context, uint64, string, []byte, *types.Session) error
}

func NewClickhouseIngester 

func NewClickhouseIngester(db Database) Ingester

func NewQueueIngester 

func NewQueueIngester(queue *persistentqueue.Queue) Ingester

type Insertable 

type Insertable interface {
	AsInsertStmt(tz *time.Location) string
}

type QueueIngester 

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

func (*QueueIngester) IngestEventData 

func (q *QueueIngester) IngestEventData(
	ctx context.Context, projectID uint64, payloadType string, payload []byte, _ *types.Event) error

func (*QueueIngester) IngestMessageData 

func (q *QueueIngester) IngestMessageData(
	ctx context.Context, projectID uint64, payloadType string, payload []byte, _ *types.Event) error

func (*QueueIngester) IngestSessionData 

func (q *QueueIngester) IngestSessionData(
	ctx context.Context, projectID uint64, payloadType string, payload []byte, session *types.Session) error

type QueueItem 

type QueueItem struct {
	Type      string `json:"type"`
	Payload   []byte `json:"payload"`
	ProjectID uint64 `json:"projectID"`
}

When client-side buffering is enabled, we only buffer the received payload once validated. All post-processing is then delegated to a queue consuming process to keep write paths as performant as possible.

type QueueItemHandler 

type QueueItemHandler interface {
	Handle(projectID uint64, item interface{}, payload []byte, b *EventsBatchPackage) error
}

type RateLimiter 

type RateLimiter interface {
	IsAllowed(context.Context, int, string, string) (*redis_rate.Result, error)
	SetLimits(*ratelimiting.LimitsConfig)
}

func NewNullRateLimiter 

func NewNullRateLimiter() RateLimiter

func NewRateLimiter 

func NewRateLimiter(limiter RateLimiterBackend) RateLimiter

type RateLimiterBackend 

type RateLimiterBackend interface {
	Allow(context.Context, string, redis_rate.Limit) (*redis_rate.Result, error)
}

type RequestDeniedHeadersSetter 

type RequestDeniedHeadersSetter interface {
	SetRetryAfter(retryAfter int64)
	SetXSentryRateLimitLimit(xSentryRateLimitLimit int64)
	SetXSentryRateLimitReset(xSentryRateLimitReset int64)
	SetXSentryRateLimits(xSentryRateLimits string)
}

type RequestPermittedHeadersSetter 

type RequestPermittedHeadersSetter interface {
	SetXSentryRateLimitLimit(xSentryRateLimitLimit int64)
	SetXSentryRateLimitRemaining(xSentryRateLimitRemaining int64)
	SetXSentryRateLimitReset(xSentryRateLimitReset int64)
}

type SentryExceptionManager 

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

func (*SentryExceptionManager) InsertEvent 

func (se *SentryExceptionManager) InsertEvent(
	ctx context.Context, projectID uint64, payloadType string, e *types.Event, payload []byte) error

func (*SentryExceptionManager) Validate 

func (se *SentryExceptionManager) Validate(e *types.Event) error

type SentryMessageManager 

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

func (*SentryMessageManager) InsertEvent 

func (se *SentryMessageManager) InsertEvent(
	ctx context.Context, projectID uint64, payloadType string, e *types.Event, payload []byte) error

func (*SentryMessageManager) Validate 

func (se *SentryMessageManager) Validate(e *types.Event) error

type SessionHandler 

type SessionHandler struct{}

func (*SessionHandler) Handle 

func (s *SessionHandler) Handle(
	projectID uint64, item interface{}, payload []byte, b *EventsBatchPackage) error

Source Files

View all Source files

Directories

Path Synopsis
gen
models
restapi
Package restapi Error Tracking REST API
 Package restapi Error Tracking REST API
restapi/operations
restapi/operations/errors
restapi/operations/errors_v2
restapi/operations/events
restapi/operations/messages
restapi/operations/projects

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.