bigslice: github.com/grailbio/bigslice/metrics Index | Examples | Files

package metrics

import "github.com/grailbio/bigslice/metrics"

Package metrics defines a set of primitives for declaring and managing metrics within Bigslice. Users declare metrics (such as a counter) using the registration mechanisms provided by this package (e.g., NewCounter). These return handles that are used for metric operations (e.g., incrementing a counter).

Every operation on a metric is performed in a Scope. Scopes are provided by the Bigslice runtime and represent an operational scope in which the metric is aggregated. For example, Bigslice defines a Scope that is attached to each task scheduled by the system. Scopes are merged by the Bigslice runtime to provide aggregated metrics across larger operations (e.g., a single session.Run).

User functions called by Bigslice are supplied a scope through the optional context.Context argument. The user must retrieve this Scope using the ContextScope func.

Metrics cannot be declared concurrently.

Index

Examples

Package Files

metrics.go scope.go

func ScopedContext Uses

❖
func ScopedContext(ctx context.Context, scope *Scope) context.Context

ScopedContext returns a context with the provided scope attached. The scope may be retrieved by ContextScope.

type Counter Uses

❖
type Counter struct {
    // contains filtered or unexported fields
}

Counter is a simple counter metric. Counters implement atomic addition and subtraction on top of an int64.

Example

Code: 

filterCount := metrics.NewCounter()
filterFunc := bigslice.Func(func() (slice bigslice.Slice) {
    slice = bigslice.Const(1, []int{1, 2, 3, 4, 5, 6})
    slice = bigslice.Filter(slice, func(ctx context.Context, i int) bool {
        scope := metrics.ContextScope(ctx)
        if i%2 == 0 {
            filterCount.Incr(scope, 1)
            return false
        }
        return true
    })
    return
})

sess := exec.Start(exec.Local)
res, err := sess.Run(context.Background(), filterFunc)
if err != nil {
    log.Fatal(err)
}

fmt.Println("filtered:", filterCount.Value(res.Scope()))

Output:

filtered: 3

func NewCounter Uses

❖
func NewCounter() Counter

NewCounter creates, registers, and returns a new Counter metric.

func (Counter) Incr Uses

❖
func (c Counter) Incr(scope *Scope, n int64)

Incr increments this counter's value in the provided scope by n.

func (Counter) Value Uses

❖
func (c Counter) Value(scope *Scope) int64

Value retrieves the current value of this metric in the provided scope.

type Metric Uses

❖
type Metric interface {
    // contains filtered or unexported methods
}

Metric is the abstract type of a metric. Each metric type must implement a set of generic operations; the metric-specific operations are provided by the metric types themselves.

TODO(marius): eventually consider opening up this interface to allow users to provide their own metrics implementations.

type Scope Uses

❖
type Scope struct {
    // contains filtered or unexported fields
}

Scope is a collection of metric instances.

func ContextScope Uses

❖
func ContextScope(ctx context.Context) *Scope

ContextScope returns the scope attached to the provided context. ContextScope panics if the context does not have an attached scope.

func (*Scope) GobDecode Uses

❖
func (s *Scope) GobDecode(p []byte) error

GobDecode implements a custom gob decoder for scopes.

func (*Scope) GobEncode Uses

❖
func (s *Scope) GobEncode() ([]byte, error)

GobEncode implements a custom gob encoder for scopes.

func (*Scope) Merge Uses

❖
func (s *Scope) Merge(u *Scope)

Merge merges instances from Scope u into Scope s.

func (*Scope) Reset Uses

❖
func (s *Scope) Reset(u *Scope)

Reset resets the scope s to u. It is reset to its initial (zero) state if u is nil.

Package metrics imports 6 packages (graph) and is imported by 1 packages. Updated 2019-12-14. Refresh now. Tools for package owners.