storage

Documentation

Index

• Constants
• type EventStorageConsumer
• type EventStorageProducer
• type EventsStorage
• type ImpressionStorage
• type ImpressionStorageConsumer
• type ImpressionStorageProducer
• type MetricWrapper
  • func NewMetricWrapper(telemetry MetricsStorage, localTelemetry MetricsStorage, ...) *MetricWrapper
  • func (m *MetricWrapper) StoreCounters(key int, value string)
  • func (m *MetricWrapper) StoreLatencies(key int, bucket int)
• type MetricsStorage
• type MetricsStorageConsumer
• type MetricsStorageProducer
• type SegmentStorage
• type SegmentStorageConsumer
• type SegmentStorageProducer
• type SplitStorage
• type SplitStorageConsumer
• type SplitStorageProducer

Constants

const (
	// SplitChangesCounter counters
	SplitChangesCounter = iota
	// SplitChangesLatency latencies
	SplitChangesLatency
	// SegmentChangesCounter counters
	SegmentChangesCounter
	// SegmentChangesLatency latencies
	SegmentChangesLatency
	// TestImpressionsCounter counter
	TestImpressionsCounter
	// TestImpressionsLatency latencies
	TestImpressionsLatency
	// PostEventsCounter counter
	PostEventsCounter
	//PostEventsLatency latencies
	PostEventsLatency
	// MySegmentsCounter counters
	MySegmentsCounter
	// MySegmentsLatency latencies
	MySegmentsLatency
)

Types

type EventStorageConsumer

type EventStorageConsumer interface {
	Count() int64
	Drop(size *int64) error
	Empty() bool
	PopN(n int64) ([]dtos.EventDTO, error)
	PopNWithMetadata(n int64) ([]dtos.QueueStoredEventDTO, error)
}

EventStorageConsumer interface should be implemented by structs that offer popping impressions

type EventStorageProducer

type EventStorageProducer interface {
	Push(event dtos.EventDTO, size int) error
}

EventStorageProducer interface should be implemented by structs that accept incoming events

type EventsStorage

type EventsStorage interface {
	EventStorageConsumer
	EventStorageProducer
}

EventsStorage wraps consumer and producer interfaces

type ImpressionStorage

type ImpressionStorage interface {
	ImpressionStorageConsumer
	ImpressionStorageProducer
}

ImpressionStorage wraps consumer & producer interfaces

type ImpressionStorageConsumer

type ImpressionStorageConsumer interface {
	Count() int64
	Drop(size *int64) error
	Empty() bool
	PopN(n int64) ([]dtos.Impression, error)
	PopNWithMetadata(n int64) ([]dtos.ImpressionQueueObject, error)
}

ImpressionStorageConsumer interface should be implemented by structs that offer popping impressions

type ImpressionStorageProducer

type ImpressionStorageProducer interface {
	LogImpressions(impressions []dtos.Impression) error
}

ImpressionStorageProducer interface should be impemented by structs that accept incoming impressions

type MetricWrapper

type MetricWrapper struct {
	Telemetry      MetricsStorage
	LocalTelemetry MetricsStorage
	// contains filtered or unexported fields
}

MetricWrapper struct

func NewMetricWrapper

func NewMetricWrapper(telemetry MetricsStorage, localTelemetry MetricsStorage, logger logging.LoggerInterface) *MetricWrapper

NewMetricWrapper builds new wrapper

func (*MetricWrapper) StoreCounters

func (m *MetricWrapper) StoreCounters(key int, value string)

StoreCounters stores counters

func (*MetricWrapper) StoreLatencies

func (m *MetricWrapper) StoreLatencies(key int, bucket int)

StoreLatencies stores counters

type MetricsStorage

type MetricsStorage interface {
	MetricsStorageConsumer
	MetricsStorageProducer
}

MetricsStorage wraps consumer and producer interfaces

type MetricsStorageConsumer

type MetricsStorageConsumer interface {
	PeekCounters() map[string]int64
	PeekLatencies() map[string][]int64
	PopGauges() []dtos.GaugeDTO
	PopLatencies() []dtos.LatenciesDTO
	PopCounters() []dtos.CounterDTO
	PopGaugesWithMetadata() (*dtos.GaugeDataBulk, error)
	PopLatenciesWithMetadata() (*dtos.LatencyDataBulk, error)
	PopCountersWithMetadata() (*dtos.CounterDataBulk, error)
}

MetricsStorageConsumer interface should be implemented by structs that offer popping metrics

type MetricsStorageProducer

type MetricsStorageProducer interface {
	PutGauge(key string, gauge float64)
	IncLatency(metricName string, index int)
	IncCounter(key string)
}

MetricsStorageProducer interface should be impemented by structs that accept incoming metrics

type SegmentStorage

type SegmentStorage interface {
	SegmentStorageProducer
	SegmentStorageConsumer
}

SegmentStorage wraps consumer and producer interfaces

type SegmentStorageConsumer

type SegmentStorageConsumer interface {
	ChangeNumber(segmentName string) (int64, error)
	CountRemovedKeys(segmentName string) int64
	Keys(segmentName string) *set.ThreadUnsafeSet
	SegmentContainsKey(segmentName string, key string) (bool, error)
}

SegmentStorageConsumer interface should be implemented by all structs that ofer reading segments

type SegmentStorageProducer

type SegmentStorageProducer interface {
	Update(name string, toAdd *set.ThreadUnsafeSet, toRemove *set.ThreadUnsafeSet, changeNumber int64) error
	SetChangeNumber(segmentName string, till int64) error
}

SegmentStorageProducer interface should be implemented by all structs that offer writing segments

type SplitStorage

type SplitStorage interface {
	SplitStorageProducer
	SplitStorageConsumer
}

SplitStorage wraps consumer & producer interfaces

type SplitStorageConsumer

type SplitStorageConsumer interface {
	All() []dtos.SplitDTO
	ChangeNumber() (int64, error)
	FetchMany(splitNames []string) map[string]*dtos.SplitDTO
	SegmentNames() *set.ThreadUnsafeSet // Not in Spec
	Split(splitName string) *dtos.SplitDTO
	SplitNames() []string
	TrafficTypeExists(trafficType string) bool
}

SplitStorageConsumer should be implemented by structs that offer reading splits from storage

type SplitStorageProducer

type SplitStorageProducer interface {
	KillLocally(splitName string, defaultTreatment string, changeNumber int64)
	PutMany(splits []dtos.SplitDTO, changeNumber int64)
	Remove(splitName string)
	SetChangeNumber(changeNumber int64) error
}

SplitStorageProducer should be implemented by structs that offer writing splits in storage