cortex

Documentation

Index

• Constants
• func DisableSignalHandling(config *server.Config)
• func NewServerService(serv *server.Server, servicesToWaitFor func() []services.Service) services.Service
• func ThanosTracerStreamInterceptor(srv interface{}, ss grpc.ServerStream, _ *grpc.StreamServerInfo, ...) error
• func ThanosTracerUnaryInterceptor(ctx context.Context, req interface{}, _ *grpc.UnaryServerInfo, ...) (interface{}, error)
• type Config
  • func (c *Config) RegisterFlags(f *flag.FlagSet)
  • func (c *Config) Validate(log log.Logger) error
• type Cortex
  • func New(cfg Config) (*Cortex, error)
  • func (t *Cortex) Run() error

Constants

const (
	API                      string = "api"
	Ring                     string = "ring"
	RuntimeConfig            string = "runtime-config"
	Overrides                string = "overrides"
	Server                   string = "server"
	Distributor              string = "distributor"
	DistributorService       string = "distributor-service"
	Ingester                 string = "ingester"
	IngesterService          string = "ingester-service"
	Flusher                  string = "flusher"
	Querier                  string = "querier"
	Queryable                string = "queryable"
	StoreQueryable           string = "store-queryable"
	QueryFrontend            string = "query-frontend"
	QueryFrontendTripperware string = "query-frontend-tripperware"
	Store                    string = "store"
	DeleteRequestsStore      string = "delete-requests-store"
	TableManager             string = "table-manager"
	RulerStorage             string = "ruler-storage"
	Ruler                    string = "ruler"
	Configs                  string = "configs"
	AlertManager             string = "alertmanager"
	Compactor                string = "compactor"
	StoreGateway             string = "store-gateway"
	MemberlistKV             string = "memberlist-kv"
	Purger                   string = "purger"
	All                      string = "all"
)

The various modules that make up Cortex.

Functions

func DisableSignalHandling

func DisableSignalHandling(config *server.Config)

DisableSignalHandling puts a dummy signal handler

func NewServerService

func NewServerService(serv *server.Server, servicesToWaitFor func() []services.Service) services.Service

NewServerService constructs service from Server component. servicesToWaitFor is called when server is stopping, and should return all services that need to terminate before server actually stops. N.B.: this function is NOT Cortex specific, please let's keep it that way. Passed server should not react on signals. Early return from Run function is considered to be an error.

func ThanosTracerStreamInterceptor

func ThanosTracerStreamInterceptor(srv interface{}, ss grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error

ThanosTracerStreamInterceptor injects the opentracing global tracer into the context in order to get it picked up by Thanos components.

func ThanosTracerUnaryInterceptor

func ThanosTracerUnaryInterceptor(ctx context.Context, req interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error)

ThanosTracerUnaryInterceptor injects the opentracing global tracer into the context in order to get it picked up by Thanos components.

Types

type Config

type Config struct {
	Target      flagext.StringSliceCSV `yaml:"target"`
	AuthEnabled bool                   `yaml:"auth_enabled"`
	PrintConfig bool                   `yaml:"-"`
	HTTPPrefix  string                 `yaml:"http_prefix"`

	API            api.Config               `yaml:"api"`
	Server         server.Config            `yaml:"server"`
	Distributor    distributor.Config       `yaml:"distributor"`
	Querier        querier.Config           `yaml:"querier"`
	IngesterClient client.Config            `yaml:"ingester_client"`
	Ingester       ingester.Config          `yaml:"ingester"`
	Flusher        flusher.Config           `yaml:"flusher"`
	Storage        storage.Config           `yaml:"storage"`
	ChunkStore     chunk.StoreConfig        `yaml:"chunk_store"`
	Schema         chunk.SchemaConfig       `yaml:"schema" doc:"hidden"` // Doc generation tool doesn't support it because part of the SchemaConfig doesn't support CLI flags (needs manual documentation)
	LimitsConfig   validation.Limits        `yaml:"limits"`
	Prealloc       client.PreallocConfig    `yaml:"prealloc" doc:"hidden"`
	Worker         frontend.WorkerConfig    `yaml:"frontend_worker"`
	Frontend       frontend.Config          `yaml:"frontend"`
	QueryRange     queryrange.Config        `yaml:"query_range"`
	TableManager   chunk.TableManagerConfig `yaml:"table_manager"`
	Encoding       encoding.Config          `yaml:"-"` // No yaml for this, it only works with flags.
	BlocksStorage  tsdb.BlocksStorageConfig `yaml:"blocks_storage"`
	Compactor      compactor.Config         `yaml:"compactor"`
	StoreGateway   storegateway.Config      `yaml:"store_gateway"`
	PurgerConfig   purger.Config            `yaml:"purger"`

	Ruler         ruler.Config                               `yaml:"ruler"`
	Configs       configs.Config                             `yaml:"configs"`
	Alertmanager  alertmanager.MultitenantAlertmanagerConfig `yaml:"alertmanager"`
	RuntimeConfig runtimeconfig.ManagerConfig                `yaml:"runtime_config"`
	MemberlistKV  memberlist.KVConfig                        `yaml:"memberlist"`
}

Config is the root config for Cortex.

func (*Config) RegisterFlags

func (c *Config) RegisterFlags(f *flag.FlagSet)

RegisterFlags registers flag.

func (*Config) Validate

func (c *Config) Validate(log log.Logger) error

Validate the cortex config and returns an error if the validation doesn't pass

type Cortex

type Cortex struct {
	Cfg Config

	// set during initialization
	ServiceMap    map[string]services.Service
	ModuleManager *modules.Manager

	API                      *api.API
	Server                   *server.Server
	Ring                     *ring.Ring
	Overrides                *validation.Overrides
	Distributor              *distributor.Distributor
	Ingester                 *ingester.Ingester
	Flusher                  *flusher.Flusher
	Store                    chunk.Store
	DeletesStore             *purger.DeleteStore
	Frontend                 *frontend.Frontend
	TableManager             *chunk.TableManager
	RuntimeConfig            *runtimeconfig.Manager
	Purger                   *purger.Purger
	TombstonesLoader         *purger.TombstonesLoader
	QuerierQueryable         prom_storage.SampleAndChunkQueryable
	QuerierEngine            *promql.Engine
	QueryFrontendTripperware frontend.Tripperware

	Ruler        *ruler.Ruler
	RulerStorage rules.RuleStore
	ConfigAPI    *configAPI.API
	ConfigDB     db.DB
	Alertmanager *alertmanager.MultitenantAlertmanager
	Compactor    *compactor.Compactor
	StoreGateway *storegateway.StoreGateway
	MemberlistKV *memberlist.KVInitService

	// Queryables that the querier should use to query the long
	// term storage. It depends on the storage engine used.
	StoreQueryables []querier.QueryableWithFilter
}

Cortex is the root datastructure for Cortex.

func New

func New(cfg Config) (*Cortex, error)

New makes a new Cortex.

func (*Cortex) Run

func (t *Cortex) Run() error

Run starts Cortex running, and blocks until a Cortex stops.