indexgateway

Documentation

Index

• Constants
• type Config
  • func (cfg *Config) RegisterFlags(f *flag.FlagSet)
• type Gateway
  • func NewIndexGateway(cfg Config, log log.Logger, registerer prometheus.Registerer, ...) (*Gateway, error)
  • func (g *Gateway) GetChunkRef(ctx context.Context, req *logproto.GetChunkRefRequest) (*logproto.GetChunkRefResponse, error)
  • func (g *Gateway) GetSeries(ctx context.Context, req *logproto.GetSeriesRequest) (*logproto.GetSeriesResponse, error)
  • func (g *Gateway) GetStats(ctx context.Context, req *logproto.IndexStatsRequest) (*logproto.IndexStatsResponse, error)
  • func (g *Gateway) LabelNamesForMetricName(ctx context.Context, req *logproto.LabelNamesForMetricNameRequest) (*logproto.LabelResponse, error)
  • func (g *Gateway) LabelValuesForMetricName(ctx context.Context, req *logproto.LabelValuesForMetricNameRequest) (*logproto.LabelResponse, error)
  • func (g *Gateway) QueryIndex(request *logproto.QueryIndexRequest, ...) error
• type IndexClient
• type IndexQuerier
• type ManagerMode
• type Mode
  • func (i Mode) Set(v string) error
  • func (i Mode) String() string
• type RingCfg
  • func (cfg *RingCfg) RegisterFlags(prefix, storePrefix string, f *flag.FlagSet)
• type RingManager
  • func NewRingManager(managerMode ManagerMode, cfg Config, log log.Logger, ...) (*RingManager, error)
  • func (rm *RingManager) IndexGatewayOwnsTenant(tenant string) bool
  • func (rm *RingManager) OnRingInstanceHeartbeat(_ *ring.BasicLifecycler, _ *ring.Desc, _ *ring.InstanceDesc)
  • func (rm *RingManager) OnRingInstanceRegister(_ *ring.BasicLifecycler, ringDesc ring.Desc, instanceExists bool, ...) (ring.InstanceState, ring.Tokens)
  • func (rm *RingManager) OnRingInstanceStopping(_ *ring.BasicLifecycler)
  • func (rm *RingManager) OnRingInstanceTokens(_ *ring.BasicLifecycler, _ ring.Tokens)
  • func (rm *RingManager) ServeHTTP(w http.ResponseWriter, req *http.Request)

Constants

const (

	// RingIdentifier is used as a unique name to register the Index Gateway ring.
	RingIdentifier = "index-gateway"

	// RingKey is the name of the key used to register the different Index Gateway instances in the key-value store.
	RingKey = "index-gateway"
)

Types

type Config

type Config struct {
	// Mode configures in which mode the client will be running when querying and communicating with an Index Gateway instance.
	Mode Mode `yaml:"mode"`

	// Ring configures the ring key-value store used to save and retrieve the different Index Gateway instances.
	//
	// In case it isn't explicitly set, it follows the same behavior of the other rings (ex: using the common configuration
	// section and the ingester configuration by default).
	Ring RingCfg `yaml:"ring,omitempty"`
}

Config configures an Index Gateway server.

func (*Config) RegisterFlags

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

RegisterFlags register all IndexGatewayClientConfig flags and all the flags of its subconfigs but with a prefix (ex: shipper).

type Gateway

type Gateway struct {
	services.Service
	// contains filtered or unexported fields
}

func NewIndexGateway

func NewIndexGateway(cfg Config, log log.Logger, registerer prometheus.Registerer, indexQuerier IndexQuerier, indexClient IndexClient) (*Gateway, error)

NewIndexGateway instantiates a new Index Gateway and start its services.

In case it is configured to be in ring mode, a Basic Service wrapping the ring client is started. Otherwise, it starts an Idle Service that doesn't have lifecycle hooks.

func (*Gateway) GetChunkRef

func (g *Gateway) GetChunkRef(ctx context.Context, req *logproto.GetChunkRefRequest) (*logproto.GetChunkRefResponse, error)

func (*Gateway) GetSeries

func (g *Gateway) GetSeries(ctx context.Context, req *logproto.GetSeriesRequest) (*logproto.GetSeriesResponse, error)

func (*Gateway) GetStats

func (g *Gateway) GetStats(ctx context.Context, req *logproto.IndexStatsRequest) (*logproto.IndexStatsResponse, error)

func (*Gateway) LabelNamesForMetricName

func (g *Gateway) LabelNamesForMetricName(ctx context.Context, req *logproto.LabelNamesForMetricNameRequest) (*logproto.LabelResponse, error)

func (*Gateway) LabelValuesForMetricName

func (g *Gateway) LabelValuesForMetricName(ctx context.Context, req *logproto.LabelValuesForMetricNameRequest) (*logproto.LabelResponse, error)

func (*Gateway) QueryIndex

func (g *Gateway) QueryIndex(request *logproto.QueryIndexRequest, server logproto.IndexGateway_QueryIndexServer) error

type IndexClient

type IndexClient interface {
	QueryPages(ctx context.Context, queries []index.Query, callback index.QueryPagesCallback) error
	Stop()
}

type IndexQuerier

type IndexQuerier interface {
	GetChunkRefs(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) ([][]chunk.Chunk, []*fetcher.Fetcher, error)
	GetSeries(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) ([]labels.Labels, error)
	LabelValuesForMetricName(ctx context.Context, userID string, from, through model.Time, metricName string, labelName string, matchers ...*labels.Matcher) ([]string, error)
	LabelNamesForMetricName(ctx context.Context, userID string, from, through model.Time, metricName string) ([]string, error)
	Stats(ctx context.Context, userID string, from, through model.Time, matchers ...*labels.Matcher) (*stats.Stats, error)
	Stop()
}

type ManagerMode

type ManagerMode int

ManagerMode defines the different modes for the RingManager to execute.

The RingManager and its modes are only relevant if the IndexGateway is running in ring mode.

const (
	// ClientMode is the RingManager mode executed by Loki components that are clients of the IndexGateway.
	// The RingManager in client will have its own ring key-value store but it won't try to register itself in the ring.
	ClientMode ManagerMode = iota

	// ServerMode is the RingManager mode execute by the IndexGateway.
	// The RingManager in server mode will register itself in the ring.
	ServerMode
)

type Mode

type Mode string

Mode represents in which mode an Index Gateway instance is running.

Right now, two modes are supported: simple mode (default) and ring mode.

const (
	// SimpleMode is a mode where an Index Gateway instance solely handle all the work.
	SimpleMode Mode = "simple"

	// RingMode is a mode where different Index Gateway instances are assigned to handle different tenants.
	//
	// It is more horizontally scalable than the simple mode, but requires running a key-value store ring.
	RingMode Mode = "ring"
)

func (Mode) Set

func (i Mode) Set(v string) error

Set implements a flag interface, and is necessary to use the IndexGatewayClientMode as a flag.

func (Mode) String

func (i Mode) String() string

String implements a flag interface, and is necessary to use the IndexGatewayClientMode as a flag.

type RingCfg

type RingCfg struct {
	// InternalRingCfg configures the Index Gateway ring.
	loki_util.RingConfig `yaml:",inline"`

	// ReplicationFactor defines how many Index Gateway instances are assigned to each tenant.
	//
	// Whenever the store queries the ring key-value store for the Index Gateway instance responsible for tenant X,
	// multiple Index Gateway instances are expected to be returned as Index Gateway might be busy/locked for specific
	// reasons (this is assured by the spikey behavior of Index Gateway latencies).
	ReplicationFactor int `yaml:"replication_factor"`
}

RingCfg is a wrapper for our Index Gateway ring configuration plus the replication factor.

func (*RingCfg) RegisterFlags

func (cfg *RingCfg) RegisterFlags(prefix, storePrefix string, f *flag.FlagSet)

RegisterFlagsWithPrefix register all Index Gateway flags related to its ring but with a proper store prefix to avoid conflicts.

type RingManager

type RingManager struct {
	services.Service

	RingLifecycler *ring.BasicLifecycler
	Ring           *ring.Ring
	// contains filtered or unexported fields
}

RingManager is a component instantiated before all the others and is responsible for the ring setup.

All Loki components that are involved with the IndexGateway (including the IndexGateway itself) will require a RingManager. However, the components that are clients of the IndexGateway will ran it in client mode while the IndexGateway itself will ran the manager in server mode.

func NewRingManager

func NewRingManager(managerMode ManagerMode, cfg Config, log log.Logger, registerer prometheus.Registerer) (*RingManager, error)

NewRingManager is the recommended way of instantiating a RingManager.

The other functions will assume the RingManager was instantiated through this function.

func (*RingManager) IndexGatewayOwnsTenant

func (rm *RingManager) IndexGatewayOwnsTenant(tenant string) bool

IndexGatewayOwnsTenant dictates if a given tenant should be ignored by an IndexGateway or not.

It fallbacks to true so that the IndexGateway will only skip tenants if it is certain of that. This implementation relies on the tokens assigned to an IndexGateway instance to define if a tenant is assigned or not.

func (*RingManager) OnRingInstanceHeartbeat

func (rm *RingManager) OnRingInstanceHeartbeat(_ *ring.BasicLifecycler, _ *ring.Desc, _ *ring.InstanceDesc)

func (*RingManager) OnRingInstanceRegister

func (rm *RingManager) OnRingInstanceRegister(_ *ring.BasicLifecycler, ringDesc ring.Desc, instanceExists bool, instanceID string, instanceDesc ring.InstanceDesc) (ring.InstanceState, ring.Tokens)

func (*RingManager) OnRingInstanceStopping

func (rm *RingManager) OnRingInstanceStopping(_ *ring.BasicLifecycler)

func (*RingManager) OnRingInstanceTokens

func (rm *RingManager) OnRingInstanceTokens(_ *ring.BasicLifecycler, _ ring.Tokens)

func (*RingManager) ServeHTTP

func (rm *RingManager) ServeHTTP(w http.ResponseWriter, req *http.Request)

ServeHTTP serves the HTTP route /indexgateway/ring.