alihan/fn-serverless
1
0
Fork 0
mirror of https://github.com/fnproject/fn.git synced 2022-10-28 21:29:17 +03:00
Code Issues Packages Projects Releases Wiki Activity

adding imgpull details (#1538)

Browse Source 
Adding PullResult struct to obtain num_retries and real pull duration
adjusting the order of the callfinished rpc response, reverting to older format, adding new fields at the bottom to maintain order

deref docker metrics in call
This commit is contained in:
Vik Bharadwaj
2019-08-05 09:14:40 -07:00
parent a036af93d8
commit 9dec87ffe7
14 changed files with 235 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
api/agent/agent.go
View File

@@ -884,7 +884,8 @@ func (a *agent) runHot(ctx context.Context, caller slotCaller, call *call, tok R
if needsPull {
waitStart := time.Now()
pullCtx, pullCancel := context.WithTimeout(ctx, a.cfg.HotPullTimeout)
err = cookie.PullImage(pullCtx)
pullRes := cookie.PullImage(pullCtx)
err = pullRes.Err
pullCancel()
if err != nil && pullCtx.Err() == context.DeadlineExceeded {
err = models.ErrDockerPullTimeout
@@ -897,6 +898,8 @@ func (a *agent) runHot(ctx context.Context, caller slotCaller, call *call, tok R
}
}
call.AddDockerWaitTime(time.Since(waitStart))
call.AddDockerPullTime(pullRes.Duration)
call.SetDockerPullRetries(pullRes.Retries)
}
if tryQueueErr(err, errQueue) != nil {
return

31
api/agent/call.go
View File

@@ -295,7 +295,13 @@ type call struct {
userExecTime *time.Duration
// amount of time attributed to docker-pull wait
dockerWaitTime time.Duration
dockerPullTime *time.Duration
// amount of time attributed to docker-pull wait
dockerWaitTime *time.Duration
// amount of time attributed to docker-pull wait
dockerPullRetries int32
// LB & Pure Runner Extra Config
extensions map[string]string
@@ -419,13 +425,22 @@ func GetCallLatencies(c *call) (time.Duration, time.Duration) {
}
func (c *call) AddDockerWaitTime(dur time.Duration) {
c.dockerWaitTime += dur
// We expose this on the upstream models.Call also.
// CallListeners have access to the latter, but not the internals of the agent, so any
// reporting or bean-counting that's going on from there will need access to this.
c.Model().DockerWaitDuration = c.dockerWaitTime
if c.dockerWaitTime == nil {
c.dockerWaitTime = new(time.Duration)
}
*c.dockerWaitTime += dur
c.Model().DockerWaitDuration = *c.dockerWaitTime
}
func (c *call) GetDockerWaitTime() time.Duration {
return c.dockerWaitTime
func (c *call) AddDockerPullTime(dur time.Duration) {
if c.dockerPullTime == nil {
c.dockerPullTime = new(time.Duration)
}
*c.dockerPullTime += dur
c.Model().DockerPullDuration = *c.dockerPullTime
}
func (c *call) SetDockerPullRetries(retries int32) {
c.dockerPullRetries = retries
c.Model().DockerPullRetries = c.dockerPullRetries
}

11
api/agent/drivers/docker/cookie.go
View File

@@ -7,6 +7,7 @@ import (
"net/http"
"path"
"strings"
"time"
"github.com/fnproject/fn/api/agent/drivers"
"github.com/fnproject/fn/api/common"
@@ -450,15 +451,15 @@ func (c *cookie) ValidateImage(ctx context.Context) (bool, error) {
}
// implements Cookie
func (c *cookie) PullImage(ctx context.Context) error {
func (c *cookie) PullImage(ctx context.Context) drivers.PullResult {
ctx, log := common.LoggerWithFields(ctx, logrus.Fields{"stack": "PullImage"})
if c.image != nil {
return nil
return drivers.PullResult{Err: nil, Retries: 0, Duration: 0 * time.Second}
}
cfg, err := c.authImage(ctx)
if err != nil {
return err
return drivers.PullResult{Err: err, Retries: 0, Duration: 0 * time.Second}
}
repo := path.Join(c.imgReg, c.imgRepo)
@@ -467,8 +468,8 @@ func (c *cookie) PullImage(ctx context.Context) error {
log.WithFields(logrus.Fields{"call_id": c.task.Id(), "image": c.task.Image()}).Debug("docker pull")
ctx = common.WithLogger(ctx, log)
errC := c.drv.imgPuller.PullImage(ctx, cfg, c.task.Image(), repo, c.imgTag)
return <-errC
pullRes := c.drv.imgPuller.PullImage(ctx, cfg, c.task.Image(), repo, c.imgTag)
return <-pullRes
}
// implements Cookie

3
api/agent/drivers/docker/docker_test.go
View File

@@ -79,7 +79,8 @@ func commonCookiePull(ctx context.Context, cookie drivers.Cookie) error {
return err
}
if shouldPull {
err = cookie.PullImage(ctx)
pullRes := cookie.PullImage(ctx)
err = pullRes.Err
if err != nil {
return err
}

33
api/agent/drivers/docker/image_puller.go
View File

@@ -23,7 +23,7 @@ import (
// any new requests are added as listeners to the ongoing docker-pull requests.
type ImagePuller interface {
PullImage(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan error
PullImage(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan drivers.PullResult
SetRetryPolicy(policy common.BackOffConfig, checker drivers.RetryErrorChecker) error
}
@@ -37,7 +37,7 @@ type transfer struct {
repo string
tag string
listeners []chan error
listeners []chan drivers.PullResult
}
type imagePuller struct {
@@ -68,7 +68,7 @@ func (i *imagePuller) SetRetryPolicy(policy common.BackOffConfig, checker driver
}
// newTransfer initiates a new docker-pull if there's no active docker-pull present for the same image.
func (i *imagePuller) newTransfer(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan error {
func (i *imagePuller) newTransfer(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan drivers.PullResult {
key := fmt.Sprintf("%s %s %+v", repo, tag, cfg)
@@ -83,13 +83,13 @@ func (i *imagePuller) newTransfer(ctx context.Context, cfg *docker.AuthConfigura
img: img,
repo: repo,
tag: tag,
listeners: make([]chan error, 0, 1),
listeners: make([]chan drivers.PullResult, 0, 1),
}
i.transfers[key] = trx
}
errC := make(chan error, 1)
trx.listeners = append(trx.listeners, errC)
pullRes := make(chan drivers.PullResult, 1)
trx.listeners = append(trx.listeners, pullRes)
i.lock.Unlock()
@@ -98,41 +98,42 @@ func (i *imagePuller) newTransfer(ctx context.Context, cfg *docker.AuthConfigura
go i.startTransfer(trx)
}
return errC
return pullRes
}
func (i *imagePuller) pullWithRetry(trx *transfer) error {
func (i *imagePuller) pullWithRetry(trx *transfer) (error, int32, time.Duration) {
backoff := common.NewBackOff(i.backOffCfg)
timer := common.NewTimer(time.Duration(i.backOffCfg.MinDelay) * time.Millisecond)
defer timer.Stop()
var retries int32
startTime := time.Now()
for {
err := i.docker.PullImage(docker.PullImageOptions{Repository: trx.repo, Tag: trx.tag, Context: trx.ctx}, *trx.cfg)
ok, reason := i.isRetriable(err)
if !ok {
return err
return err, retries, time.Since(startTime)
}
delay, ok := backoff.NextBackOff()
if !ok {
return err
return err, retries, time.Since(startTime)
}
timer.Reset(delay)
select {
case <-timer.C:
retries += 1
recordRetry(trx.ctx, "docker_pull_image", reason)
case <-trx.ctx.Done():
return trx.ctx.Err()
return trx.ctx.Err(), retries, time.Since(startTime)
}
}
}
func (i *imagePuller) startTransfer(trx *transfer) {
var ferr error
err := i.pullWithRetry(trx)
err, retries, duration := i.pullWithRetry(trx)
if err != nil {
common.Logger(trx.ctx).WithError(err).Info("Failed to pull image")
@@ -157,7 +158,7 @@ func (i *imagePuller) startTransfer(trx *transfer) {
// notify any listeners
for _, ch := range trx.listeners {
if ferr != nil {
ch <- ferr
ch <- drivers.PullResult{Err: ferr, Retries: retries, Duration: duration}
}
close(ch)
}
@@ -166,7 +167,7 @@ func (i *imagePuller) startTransfer(trx *transfer) {
delete(i.transfers, trx.key)
}
func (i *imagePuller) PullImage(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan error {
func (i *imagePuller) PullImage(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan drivers.PullResult {
return i.newTransfer(ctx, cfg, img, repo, tag)
}

12
api/agent/drivers/docker/image_puller_test.go
View File

@@ -51,7 +51,8 @@ func TestImagePullConcurrent1(t *testing.T) {
for i := 0; i < 10; i++ {
go func() {
defer wg.Done()
err := <-puller.PullImage(ctx, &cfg, img, repo, tag1)
pullRes := <-puller.PullImage(ctx, &cfg, img, repo, tag1)
err := pullRes.Err
if err != nil {
t.Fatalf("err received %v", err)
}
@@ -60,7 +61,8 @@ func TestImagePullConcurrent1(t *testing.T) {
for i := 0; i < 10; i++ {
go func() {
defer wg.Done()
err := <-puller.PullImage(ctx, &cfg, img, repo, tag2)
pullRes := <-puller.PullImage(ctx, &cfg, img, repo, tag2)
err := pullRes.Err
if err != nil {
t.Fatalf("err received %v", err)
}
@@ -97,7 +99,8 @@ func TestImagePullConcurrent2(t *testing.T) {
for i := 0; i < 10; i++ {
go func() {
defer wg.Done()
err := <-puller.PullImage(ctx, &cfg, img, repo, tag)
pullRes := <-puller.PullImage(ctx, &cfg, img, repo, tag)
err := pullRes.Err
if err == nil || strings.Index(err.Error(), "yogurt") == -1 {
t.Fatalf("Unknown err received %v", err)
}
@@ -149,7 +152,8 @@ func TestImagePullConcurrent3(t *testing.T) {
for i := 0; i < 10; i++ {
go func() {
defer wg.Done()
err := <-puller.PullImage(ctx, &cfg, img, repo, tag)
pullRes := <-puller.PullImage(ctx, &cfg, img, repo, tag)
err := pullRes.Err
if err == nil {
t.Fatalf("no err received")
}

10
api/agent/drivers/driver.go
View File

@@ -6,6 +6,7 @@ import (
"context"
"io"
"strings"
"time"
"github.com/fnproject/fn/api/agent/drivers/stats"
"github.com/fnproject/fn/api/common"
@@ -44,7 +45,7 @@ type Cookie interface {
// Pull the image. An image pull requires validation/inspection
// again.
PullImage(ctx context.Context) error
PullImage(ctx context.Context) PullResult
// Create container which can be Run() later
CreateContainer(ctx context.Context) error
@@ -100,6 +101,13 @@ type LoggerTag struct {
Value string
}
// Configuration for Image Pull details
type PullResult struct {
Err error
Retries int32
Duration time.Duration
}
// Logger Configuration for container
type LoggerConfig struct {
// Log Sink URL

4
api/agent/drivers/mock/mocker.go
View File

@@ -52,8 +52,8 @@ func (c *cookie) ValidateImage(context.Context) (bool, error) {
return false, nil
}
func (c *cookie) PullImage(context.Context) error {
return nil
func (c *cookie) PullImage(context.Context) drivers.PullResult {
return drivers.PullResult{Err: nil, Retries: 0, Duration: 0 * time.Second}
}
func (c *cookie) CreateContainer(context.Context) error {

212
api/agent/grpc/runner.pb.go
View File

@@ -327,11 +327,13 @@ type CallFinished struct {
CreatedAt string `protobuf:"bytes,5,opt,name=createdAt,proto3" json:"createdAt,omitempty"`
StartedAt string `protobuf:"bytes,6,opt,name=startedAt,proto3" json:"startedAt,omitempty"`
CompletedAt string `protobuf:"bytes,7,opt,name=completedAt,proto3" json:"completedAt,omitempty"`
Image string `protobuf:"bytes,8,opt,name=image,proto3" json:"image,omitempty"`
SchedulerDuration int64 `protobuf:"varint,9,opt,name=schedulerDuration,proto3" json:"schedulerDuration,omitempty"`
ExecutionDuration int64 `protobuf:"varint,10,opt,name=executionDuration,proto3" json:"executionDuration,omitempty"`
DockerPullWait int64 `protobuf:"varint,11,opt,name=dockerPullWait,proto3" json:"dockerPullWait,omitempty"`
ErrorUser bool `protobuf:"varint,12,opt,name=errorUser,proto3" json:"errorUser,omitempty"`
SchedulerDuration int64 `protobuf:"varint,8,opt,name=schedulerDuration,proto3" json:"schedulerDuration,omitempty"`
ExecutionDuration int64 `protobuf:"varint,9,opt,name=executionDuration,proto3" json:"executionDuration,omitempty"`
ErrorUser bool `protobuf:"varint,10,opt,name=errorUser,proto3" json:"errorUser,omitempty"`
Image string `protobuf:"bytes,11,opt,name=image,proto3" json:"image,omitempty"`
DockerPullRetries int32 `protobuf:"varint,12,opt,name=dockerPullRetries,proto3" json:"dockerPullRetries,omitempty"`
DockerWaitDuration int64 `protobuf:"varint,13,opt,name=dockerWaitDuration,proto3" json:"dockerWaitDuration,omitempty"`
DockerPullDuration int64 `protobuf:"varint,14,opt,name=dockerPullDuration,proto3" json:"dockerPullDuration,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@@ -411,13 +413,6 @@ func (m *CallFinished) GetCompletedAt() string {
return ""
}
func (m *CallFinished) GetImage() string {
if m != nil {
return m.Image
}
return ""
}
func (m *CallFinished) GetSchedulerDuration() int64 {
if m != nil {
return m.SchedulerDuration
@@ -432,13 +427,6 @@ func (m *CallFinished) GetExecutionDuration() int64 {
return 0
}
func (m *CallFinished) GetDockerWaitTime() int64 {
if m != nil {
return m.DockerPullWait
}
return 0
}
func (m *CallFinished) GetErrorUser() bool {
if m != nil {
return m.ErrorUser
@@ -446,6 +434,34 @@ func (m *CallFinished) GetErrorUser() bool {
return false
}
func (m *CallFinished) GetImage() string {
if m != nil {
return m.Image
}
return ""
}
func (m *CallFinished) GetDockerPullRetries() int32 {
if m != nil {
return m.DockerPullRetries
}
return 0
}
func (m *CallFinished) GetDockerWaitDuration() int64 {
if m != nil {
return m.DockerWaitDuration
}
return 0
}
func (m *CallFinished) GetDockerPullDuration() int64 {
if m != nil {
return m.DockerPullDuration
}
return 0
}
type ClientMsg struct {
// Types that are valid to be assigned to Body:
// *ClientMsg_Try
@@ -1296,84 +1312,86 @@ func init() {
func init() { proto.RegisterFile("runner.proto", fileDescriptor_48eceea7e2abc593) }
var fileDescriptor_48eceea7e2abc593 = []byte{
// 1232 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x8f, 0xdb, 0x44,
0x14, 0x5e, 0xc7, 0x89, 0x93, 0xbc, 0x64, 0xb3, 0xd9, 0x51, 0x55, 0x19, 0x53, 0xd1, 0x10, 0x4a,
0x15, 0xc1, 0xd6, 0xa5, 0x0b, 0x95, 0x4a, 0x25, 0x40, 0x65, 0x77, 0xab, 0x14, 0xb5, 0xb4, 0x9a,
0xb4, 0x70, 0x5c, 0xcd, 0xda, 0x93, 0xc4, 0xc4, 0xf1, 0x84, 0x99, 0xf1, 0xd2, 0x48, 0xdc, 0xb9,
0x73, 0xe3, 0x08, 0x37, 0xee, 0xfc, 0x11, 0x9c, 0xf8, 0x73, 0x38, 0xa3, 0xf9, 0x11, 0xe7, 0x57,
0xbb, 0xed, 0x4a, 0xdc, 0xfc, 0xbe, 0xef, 0xcd, 0xbc, 0xe7, 0x37, 0xdf, 0x7b, 0x33, 0xd0, 0xe4,
0x79, 0x96, 0x51, 0x1e, 0xce, 0x38, 0x93, 0x2c, 0x78, 0x77, 0xc4, 0xd8, 0x28, 0xa5, 0xb7, 0xb5,
0x75, 0x96, 0x0f, 0x6f, 0xd3, 0xe9, 0x4c, 0xce, 0x0d, 0xd9, 0xfd, 0xc7, 0x81, 0xea, 0x73, 0x3e,
0x3f, 0x22, 0x69, 0x8a, 0x7a, 0xd0, 0x9e, 0xb2, 0x98, 0xa6, 0xe2, 0x34, 0x22, 0x69, 0x7a, 0xfa,
0x83, 0x60, 0x99, 0xef, 0x74, 0x9c, 0x5e, 0x1d, 0xb7, 0x0c, 0xae, 0xbc, 0xbe, 0x11, 0x2c, 0x43,
0x1d, 0x68, 0x8a, 0x94, 0xc9, 0xd3, 0x31, 0x11, 0xe3, 0xd3, 0x24, 0xf6, 0x4b, 0xda, 0x0b, 0x14,
0xd6, 0x27, 0x62, 0xfc, 0x28, 0x46, 0xf7, 0x00, 0xe8, 0x4b, 0x49, 0x33, 0x91, 0xb0, 0x4c, 0xf8,
0x6e, 0xc7, 0xed, 0x35, 0x0e, 0xfd, 0xd0, 0x46, 0x0a, 0x4f, 0x0a, 0xea, 0x24, 0x93, 0x7c, 0x8e,
0x57, 0x7c, 0x83, 0x2f, 0x60, 0x6f, 0x83, 0x46, 0x6d, 0x70, 0x27, 0x74, 0x6e, 0x73, 0x51, 0x9f,
0xe8, 0x0a, 0x54, 0xce, 0x49, 0x9a, 0x53, 0x1b, 0xd9, 0x18, 0xf7, 0x4b, 0xf7, 0x9c, 0xee, 0x1d,
0xa8, 0x1f, 0x13, 0x49, 0x1e, 0x72, 0x32, 0xa5, 0x08, 0x41, 0x39, 0x26, 0x92, 0xe8, 0x95, 0x4d,
0xac, 0xbf, 0xd5, 0x66, 0x94, 0x0d, 0xf5, 0xc2, 0x1a, 0x56, 0x9f, 0xdd, 0xcf, 0x00, 0xfa, 0x52,
0xce, 0xfa, 0x94, 0xc4, 0x94, 0xbf, 0x6d, 0xb0, 0xee, 0x77, 0xd0, 0x54, 0xab, 0x30, 0x15, 0xb3,
0x27, 0x54, 0x12, 0x74, 0x1d, 0x1a, 0x42, 0x12, 0x99, 0x8b, 0xd3, 0x88, 0xc5, 0x54, 0xaf, 0xaf,
0x60, 0x30, 0xd0, 0x11, 0x8b, 0x29, 0xfa, 0x10, 0xaa, 0x63, 0x1d, 0x42, 0xf8, 0x25, 0x5d, 0x8f,
0x46, 0xb8, 0x0c, 0x8b, 0x17, 0x5c, 0xf7, 0x4b, 0xd8, 0x53, 0x35, 0xc2, 0x54, 0xe4, 0xa9, 0x1c,
0x48, 0xc2, 0x25, 0xfa, 0x00, 0xca, 0x63, 0x29, 0x67, 0x7e, 0xdc, 0x71, 0x7a, 0x8d, 0xc3, 0xdd,
0x70, 0x35, 0x6e, 0x7f, 0x07, 0x6b, 0xf2, 0x6b, 0x0f, 0xca, 0x53, 0x2a, 0x49, 0xf7, 0x57, 0x17,
0x9a, 0x6a, 0x83, 0x87, 0x49, 0x96, 0x88, 0x31, 0x8d, 0x91, 0x0f, 0x55, 0x91, 0x47, 0x11, 0x15,
0x42, 0x27, 0x55, 0xc3, 0x0b, 0x53, 0x31, 0x31, 0x95, 0x24, 0x49, 0x85, 0xfd, 0xb5, 0x85, 0x89,
0xae, 0x41, 0x9d, 0x72, 0xce, 0xb8, 0x4a, 0xdc, 0x77, 0xf5, 0xaf, 0x2c, 0x01, 0x14, 0x40, 0x4d,
0x1b, 0x03, 0xc9, 0xfd, 0xb2, 0x5e, 0x58, 0xd8, 0x6a, 0x65, 0xc4, 0x29, 0x91, 0x34, 0x7e, 0x20,
0xfd, 0x8a, 0x26, 0x97, 0x80, 0x62, 0x85, 0xfa, 0x25, 0xcd, 0x7a, 0x86, 0x2d, 0x00, 0xd4, 0x81,
0x46, 0xc4, 0xa6, 0xb3, 0x94, 0x1a, 0xbe, 0xaa, 0xf9, 0x55, 0x48, 0x1d, 0x45, 0x32, 0x25, 0x23,
0xea, 0xd7, 0xcc, 0x51, 0x68, 0x03, 0x1d, 0xc0, 0xbe, 0x88, 0xc6, 0x34, 0xce, 0x53, 0xca, 0x8f,
0x73, 0x4e, 0x64, 0xc2, 0x32, 0xbf, 0xde, 0x71, 0x7a, 0x2e, 0xde, 0x26, 0x94, 0x37, 0x7d, 0x49,
0xa3, 0x5c, 0x19, 0x85, 0x37, 0x18, 0xef, 0x2d, 0x02, 0xdd, 0x84, 0x56, 0xcc, 0xa2, 0x09, 0xe5,
0xcf, 0xf2, 0x34, 0xfd, 0x9e, 0x24, 0xd2, 0x6f, 0x68, 0xd7, 0x0d, 0xb4, 0xa8, 0xd8, 0x0b, 0x41,
0xb9, 0xdf, 0xd4, 0x75, 0x5e, 0x02, 0xdd, 0x01, 0xd4, 0x8f, 0xd2, 0x84, 0x66, 0xf2, 0x89, 0x18,
0xa1, 0x6b, 0xe0, 0x4a, 0x6e, 0x14, 0xd6, 0x38, 0xac, 0x2d, 0x9a, 0xa2, 0xbf, 0x83, 0x15, 0x8c,
0x3a, 0x56, 0xb3, 0x25, 0x4d, 0x43, 0x58, 0xa8, 0x59, 0x9d, 0xb4, 0x62, 0xd4, 0x49, 0x9f, 0xb1,
0x78, 0xde, 0xfd, 0xcd, 0x81, 0x3a, 0xd6, 0x9d, 0xae, 0x76, 0xbd, 0x0b, 0x4d, 0xae, 0x35, 0x73,
0xaa, 0x0b, 0x6a, 0xb7, 0x6f, 0x87, 0x1b, 0x62, 0xea, 0xef, 0xe0, 0x06, 0x5f, 0xd1, 0xd6, 0x1b,
0xc3, 0xa1, 0x8f, 0xa1, 0x36, 0xb4, 0x5a, 0xd2, 0x52, 0x50, 0x0a, 0x5c, 0x15, 0x58, 0x7f, 0x07,
0x17, 0x0e, 0x45, 0x6e, 0x7f, 0x54, 0xa0, 0x69, 0x72, 0x1b, 0xe8, 0x0e, 0x40, 0x57, 0xc1, 0x23,
0x91, 0x4c, 0xce, 0x4d, 0x17, 0x55, 0xb0, 0xb5, 0x14, 0x3e, 0x24, 0x49, 0x6a, 0xf7, 0xae, 0x61,
0x6b, 0xa1, 0x16, 0x94, 0x92, 0xd8, 0xaa, 0xab, 0x94, 0xc4, 0xab, 0x5a, 0xad, 0x5c, 0xa0, 0x55,
0xef, 0x22, 0xad, 0x56, 0x2f, 0xd2, 0x6a, 0xed, 0x42, 0xad, 0xd6, 0xdf, 0xa0, 0x55, 0xd8, 0xd6,
0xea, 0x55, 0xf0, 0x22, 0xa2, 0xd4, 0xa7, 0x15, 0x53, 0xc3, 0xd6, 0x42, 0x1f, 0x41, 0x9b, 0xd3,
0x1f, 0x73, 0x2a, 0xa4, 0xc0, 0x34, 0xa2, 0xc9, 0x39, 0x8d, 0xb5, 0x60, 0xca, 0x78, 0x0b, 0x47,
0x3d, 0xd8, 0x5b, 0x60, 0x7d, 0x92, 0xc5, 0xaa, 0x4c, 0xbb, 0xda, 0x75, 0x13, 0x46, 0x5d, 0x68,
0x4e, 0xe2, 0x7c, 0x3a, 0x13, 0x4f, 0xb3, 0xe3, 0x44, 0x4c, 0xfc, 0x96, 0x76, 0x5b, 0xc3, 0x5e,
0xdd, 0x27, 0x7b, 0x97, 0xea, 0x93, 0xf6, 0xeb, 0xfa, 0xe4, 0x00, 0xf6, 0x13, 0xf1, 0x2d, 0x95,
0x3f, 0x31, 0x3e, 0x39, 0x4e, 0x04, 0x39, 0x53, 0xb9, 0xee, 0xeb, 0x1f, 0xdf, 0x26, 0xd0, 0x11,
0x34, 0xa3, 0x5c, 0x48, 0x36, 0x35, 0xea, 0xf0, 0x91, 0x1e, 0x88, 0xd7, 0xc3, 0x55, 0xc9, 0x84,
0x47, 0x2b, 0x1e, 0xe6, 0x9e, 0x58, 0x5b, 0x14, 0x7c, 0x05, 0xfb, 0x5b, 0x2e, 0x97, 0xba, 0x2b,
0xce, 0xa1, 0x7e, 0xc4, 0xb2, 0x61, 0x32, 0x52, 0xfd, 0x13, 0x82, 0x17, 0x69, 0xc3, 0x77, 0x74,
0x32, 0x57, 0xc3, 0x82, 0xb3, 0x5f, 0x26, 0x07, 0xeb, 0x15, 0x7c, 0x0e, 0x8d, 0x15, 0xf8, 0x52,
0x71, 0x5b, 0xd0, 0x34, 0x4b, 0x4d, 0xe2, 0xdd, 0x3f, 0x4b, 0xb0, 0xfb, 0x98, 0x8d, 0xb0, 0x39,
0x52, 0x95, 0xcc, 0x01, 0x54, 0x56, 0xbb, 0xf8, 0x4a, 0xb8, 0x46, 0x87, 0x8b, 0x4e, 0x36, 0x4e,
0xe8, 0x26, 0xb8, 0x24, 0x9a, 0xd8, 0x16, 0x46, 0x1b, 0xbe, 0x0f, 0xa2, 0x89, 0x1a, 0x2d, 0x24,
0x52, 0xe7, 0x5f, 0xe1, 0x94, 0xc4, 0x73, 0xdb, 0xc6, 0x9b, 0xbb, 0x62, 0xc5, 0xa9, 0x5d, 0xb5,
0x53, 0xf0, 0x33, 0x54, 0xcc, 0x88, 0xb8, 0xb7, 0x51, 0x99, 0xce, 0xab, 0xb2, 0xf9, 0x9f, 0x6b,
0x14, 0x54, 0xc0, 0x7d, 0x10, 0x4d, 0x82, 0x2a, 0x54, 0x74, 0x5a, 0xc5, 0x60, 0xf9, 0xd7, 0x85,
0x96, 0x0e, 0x2f, 0x66, 0x2c, 0x13, 0x54, 0x15, 0xeb, 0x56, 0x71, 0xcb, 0xab, 0xec, 0xde, 0x09,
0xd7, 0x69, 0x95, 0x98, 0x24, 0x49, 0x46, 0xb9, 0x99, 0x67, 0xc1, 0x5f, 0xae, 0x3e, 0x76, 0x83,
0xa1, 0x1b, 0xb0, 0x4b, 0x66, 0xb3, 0x34, 0x89, 0xb4, 0x8c, 0x1f, 0xc5, 0x36, 0xbb, 0x75, 0x10,
0xbd, 0x07, 0x30, 0xcc, 0xb3, 0xc8, 0xba, 0xd8, 0xe7, 0xce, 0x12, 0x31, 0xd3, 0xc0, 0x6e, 0xf9,
0xc8, 0x8c, 0x32, 0x3d, 0x0d, 0x0a, 0x08, 0xdd, 0xb5, 0x49, 0x96, 0x75, 0x92, 0xef, 0xbf, 0x36,
0xc9, 0xd0, 0x16, 0xd6, 0x26, 0xfb, 0x4b, 0x09, 0xaa, 0x16, 0x51, 0x03, 0xc9, 0x76, 0x7d, 0x91,
0xe6, 0x12, 0x40, 0xf7, 0x8b, 0x41, 0xae, 0x02, 0xdc, 0x7c, 0x63, 0x80, 0xf0, 0x71, 0x92, 0x51,
0x1b, 0xe5, 0x77, 0x07, 0xca, 0xca, 0x54, 0x21, 0x64, 0x32, 0xa5, 0x42, 0x92, 0xe9, 0x4c, 0x87,
0x70, 0xf1, 0x12, 0x40, 0x27, 0xe0, 0x09, 0x96, 0xf3, 0xc8, 0x1c, 0x57, 0xeb, 0xf0, 0xd6, 0xdb,
0x05, 0x09, 0x07, 0x7a, 0x11, 0xb6, 0x8b, 0x8b, 0x57, 0x99, 0xbb, 0x7c, 0x95, 0x75, 0x3b, 0xe0,
0x19, 0x2f, 0x04, 0xe0, 0x0d, 0x9e, 0x1f, 0x3f, 0x7d, 0xf1, 0xbc, 0xbd, 0x63, 0xbf, 0x4f, 0x30,
0x6e, 0x3b, 0x87, 0x7f, 0x3b, 0xd0, 0x32, 0xe3, 0xe1, 0x99, 0x7a, 0xb9, 0x46, 0x2c, 0x45, 0x37,
0xc0, 0x3b, 0xc9, 0x46, 0xea, 0x05, 0x00, 0x61, 0x71, 0xbd, 0x06, 0x10, 0x16, 0x97, 0x62, 0xcf,
0xf9, 0xc4, 0x41, 0xb7, 0xc1, 0x5b, 0xdc, 0x41, 0xa1, 0x79, 0x0a, 0x87, 0x8b, 0xa7, 0x70, 0x78,
0xa2, 0x9e, 0xc2, 0xc1, 0xee, 0xda, 0xdc, 0x41, 0x07, 0xb0, 0x67, 0x54, 0x9b, 0x73, 0x6a, 0x08,
0xb5, 0xff, 0x62, 0x18, 0x04, 0xbb, 0xe1, 0x6a, 0xf3, 0xa2, 0x3b, 0x00, 0x03, 0xc9, 0x29, 0x99,
0x3e, 0x66, 0x23, 0x81, 0x5a, 0xeb, 0xbd, 0x11, 0xec, 0x6d, 0x94, 0x48, 0x65, 0x74, 0xe6, 0xe9,
0xf8, 0x9f, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x26, 0x30, 0xd0, 0x69, 0xa8, 0x0b, 0x00, 0x00,
// 1256 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x5d, 0x8f, 0xdb, 0x44,
0x14, 0x5d, 0xc7, 0xf9, 0xbc, 0xf9, 0xd8, 0xec, 0xa8, 0xaa, 0x8c, 0xa9, 0x68, 0x08, 0xa5, 0x8a,
0x60, 0xeb, 0xd2, 0x85, 0x4a, 0xa5, 0x12, 0xa0, 0xb2, 0xbb, 0x55, 0x8a, 0x5a, 0x5a, 0x4d, 0x5a,
0x78, 0x5c, 0xcd, 0xda, 0xb3, 0x89, 0x89, 0xe3, 0x09, 0x33, 0xe3, 0xa5, 0x91, 0x78, 0xe7, 0x37,
0xf0, 0x08, 0x6f, 0xbc, 0xf3, 0x23, 0x78, 0xe2, 0xe7, 0x20, 0x1e, 0xd1, 0x7c, 0xc4, 0x71, 0x92,
0x76, 0xdb, 0x95, 0x78, 0xf3, 0x3d, 0xe7, 0xce, 0xdc, 0xe3, 0xf1, 0x3d, 0xd7, 0x03, 0x2d, 0x9e,
0xa5, 0x29, 0xe5, 0xc1, 0x9c, 0x33, 0xc9, 0xfc, 0x77, 0xc7, 0x8c, 0x8d, 0x13, 0x7a, 0x5b, 0x47,
0xa7, 0xd9, 0xd9, 0x6d, 0x3a, 0x9b, 0xcb, 0x85, 0x21, 0xfb, 0x7f, 0x3b, 0x50, 0x7b, 0xce, 0x17,
0x87, 0x24, 0x49, 0xd0, 0x00, 0xba, 0x33, 0x16, 0xd1, 0x44, 0x9c, 0x84, 0x24, 0x49, 0x4e, 0x7e,
0x10, 0x2c, 0xf5, 0x9c, 0x9e, 0x33, 0x68, 0xe0, 0x8e, 0xc1, 0x55, 0xd6, 0x37, 0x82, 0xa5, 0xa8,
0x07, 0x2d, 0x91, 0x30, 0x79, 0x32, 0x21, 0x62, 0x72, 0x12, 0x47, 0x5e, 0x49, 0x67, 0x81, 0xc2,
0x86, 0x44, 0x4c, 0x1e, 0x45, 0xe8, 0x1e, 0x00, 0x7d, 0x29, 0x69, 0x2a, 0x62, 0x96, 0x0a, 0xcf,
0xed, 0xb9, 0x83, 0xe6, 0x81, 0x17, 0xd8, 0x4a, 0xc1, 0x71, 0x4e, 0x1d, 0xa7, 0x92, 0x2f, 0x70,
0x21, 0xd7, 0xff, 0x02, 0x76, 0x37, 0x68, 0xd4, 0x05, 0x77, 0x4a, 0x17, 0x56, 0x8b, 0x7a, 0x44,
0x57, 0xa0, 0x72, 0x4e, 0x92, 0x8c, 0xda, 0xca, 0x26, 0xb8, 0x5f, 0xba, 0xe7, 0xf4, 0xef, 0x40,
0xe3, 0x88, 0x48, 0xf2, 0x90, 0x93, 0x19, 0x45, 0x08, 0xca, 0x11, 0x91, 0x44, 0xaf, 0x6c, 0x61,
0xfd, 0xac, 0x36, 0xa3, 0xec, 0x4c, 0x2f, 0xac, 0x63, 0xf5, 0xd8, 0xff, 0x0c, 0x60, 0x28, 0xe5,
0x7c, 0x48, 0x49, 0x44, 0xf9, 0xdb, 0x16, 0xeb, 0x7f, 0x07, 0x2d, 0xb5, 0x0a, 0x53, 0x31, 0x7f,
0x42, 0x25, 0x41, 0xd7, 0xa1, 0x29, 0x24, 0x91, 0x99, 0x38, 0x09, 0x59, 0x44, 0xf5, 0xfa, 0x0a,
0x06, 0x03, 0x1d, 0xb2, 0x88, 0xa2, 0x0f, 0xa1, 0x36, 0xd1, 0x25, 0x84, 0x57, 0xd2, 0xe7, 0xd1,
0x0c, 0x56, 0x65, 0xf1, 0x92, 0xeb, 0x7f, 0x09, 0xbb, 0xea, 0x8c, 0x30, 0x15, 0x59, 0x22, 0x47,
0x92, 0x70, 0x89, 0x3e, 0x80, 0xf2, 0x44, 0xca, 0xb9, 0x17, 0xf5, 0x9c, 0x41, 0xf3, 0xa0, 0x1d,
0x14, 0xeb, 0x0e, 0x77, 0xb0, 0x26, 0xbf, 0xae, 0x42, 0x79, 0x46, 0x25, 0xe9, 0xff, 0xeb, 0x42,
0x4b, 0x6d, 0xf0, 0x30, 0x4e, 0x63, 0x31, 0xa1, 0x11, 0xf2, 0xa0, 0x26, 0xb2, 0x30, 0xa4, 0x42,
0x68, 0x51, 0x75, 0xbc, 0x0c, 0x15, 0x13, 0x51, 0x49, 0xe2, 0x44, 0xd8, 0x57, 0x5b, 0x86, 0xe8,
0x1a, 0x34, 0x28, 0xe7, 0x8c, 0x2b, 0xe1, 0x9e, 0xab, 0x5f, 0x65, 0x05, 0x20, 0x1f, 0xea, 0x3a,
0x18, 0x49, 0xee, 0x95, 0xf5, 0xc2, 0x3c, 0x56, 0x2b, 0x43, 0x4e, 0x89, 0xa4, 0xd1, 0x03, 0xe9,
0x55, 0x34, 0xb9, 0x02, 0x14, 0x2b, 0xd4, 0x2b, 0x69, 0xb6, 0x6a, 0xd8, 0x1c, 0x40, 0x3d, 0x68,
0x86, 0x6c, 0x36, 0x4f, 0xa8, 0xe1, 0x6b, 0x9a, 0x2f, 0x42, 0x68, 0x1f, 0xf6, 0x44, 0x38, 0xa1,
0x51, 0x96, 0x50, 0x7e, 0x94, 0x71, 0x22, 0x63, 0x96, 0x7a, 0xf5, 0x9e, 0x33, 0x70, 0xf1, 0x36,
0xa1, 0xb2, 0xe9, 0x4b, 0x1a, 0x66, 0x2a, 0xc8, 0xb3, 0x1b, 0x26, 0x7b, 0x8b, 0xc8, 0xdf, 0xf9,
0x85, 0xa0, 0xdc, 0x03, 0x7d, 0x52, 0x2b, 0x40, 0x35, 0x41, 0x3c, 0x23, 0x63, 0xea, 0x35, 0x4d,
0x13, 0xe8, 0x40, 0x55, 0x88, 0x58, 0x38, 0xa5, 0xfc, 0x59, 0xa6, 0x3e, 0x99, 0xe4, 0x31, 0x15,
0x5e, 0x4b, 0x9f, 0xd7, 0x36, 0x81, 0x02, 0x40, 0x06, 0xfc, 0x9e, 0xc4, 0x32, 0x17, 0xd4, 0xd6,
0x82, 0x5e, 0xc1, 0xac, 0xf2, 0xd5, 0x26, 0x79, 0x7e, 0xa7, 0x98, 0x5f, 0x64, 0xfa, 0x23, 0x68,
0x1c, 0x26, 0x31, 0x4d, 0xe5, 0x13, 0x31, 0x46, 0xd7, 0xc0, 0x95, 0xdc, 0xf4, 0x71, 0xf3, 0xa0,
0xbe, 0xb4, 0xde, 0x70, 0x07, 0x2b, 0x18, 0xf5, 0xac, 0x33, 0x4a, 0x9a, 0x86, 0x20, 0xf7, 0x8c,
0xea, 0x27, 0xc5, 0xa8, 0x7e, 0x3a, 0x65, 0xd1, 0xa2, 0xff, 0xab, 0x03, 0x0d, 0xac, 0xe7, 0x89,
0xda, 0xf5, 0x2e, 0xb4, 0xb8, 0xee, 0xcc, 0x13, 0xfd, 0xd9, 0xec, 0xf6, 0xdd, 0x60, 0xa3, 0x65,
0x87, 0x3b, 0xb8, 0xc9, 0x0b, 0x1d, 0xfc, 0xc6, 0x72, 0xe8, 0x63, 0xa8, 0x9f, 0xd9, 0x8e, 0xd5,
0x0d, 0xa7, 0xfa, 0xbc, 0xd8, 0xc6, 0xc3, 0x1d, 0x9c, 0x27, 0xe4, 0xda, 0x7e, 0xaf, 0x40, 0xcb,
0x68, 0x1b, 0x69, 0x9f, 0xa1, 0xab, 0x50, 0x25, 0xa1, 0x8c, 0xcf, 0x8d, 0x57, 0x2b, 0xd8, 0x46,
0x0a, 0x3f, 0x23, 0x71, 0x62, 0xf7, 0xae, 0x63, 0x1b, 0xa1, 0x0e, 0x94, 0xe2, 0xc8, 0xf6, 0x70,
0x29, 0x8e, 0x8a, 0x8e, 0xa8, 0x5c, 0xe0, 0x88, 0xea, 0x45, 0x8e, 0xa8, 0x5d, 0xe4, 0x88, 0xfa,
0x85, 0x8e, 0x68, 0xbc, 0xc1, 0x11, 0xb0, 0xed, 0x88, 0xab, 0x50, 0x0d, 0x89, 0xea, 0x7c, 0xdd,
0x98, 0x75, 0x6c, 0x23, 0xf4, 0x11, 0x74, 0x39, 0xfd, 0x31, 0xa3, 0x42, 0x0a, 0x4c, 0x43, 0x1a,
0x9f, 0xd3, 0x48, 0x37, 0x66, 0x19, 0x6f, 0xe1, 0x68, 0x00, 0xbb, 0x4b, 0x6c, 0x48, 0xd2, 0x48,
0x1d, 0x53, 0x5b, 0xa7, 0x6e, 0xc2, 0xa8, 0x0f, 0xad, 0x69, 0x94, 0xcd, 0xe6, 0xe2, 0x69, 0x7a,
0x14, 0x8b, 0xa9, 0xee, 0xc5, 0x32, 0x5e, 0xc3, 0x5e, 0xed, 0xd1, 0xdd, 0x4b, 0x79, 0xb4, 0xfb,
0x3a, 0x8f, 0xee, 0xc3, 0x5e, 0x2c, 0xbe, 0xa5, 0xf2, 0x27, 0xc6, 0xa7, 0x47, 0xb1, 0x20, 0xa7,
0x4a, 0xeb, 0x9e, 0x7e, 0xf1, 0x6d, 0x02, 0x1d, 0x42, 0x2b, 0xcc, 0x84, 0x64, 0x33, 0xd3, 0x1d,
0x1e, 0xd2, 0x63, 0xf7, 0x7a, 0x50, 0x6c, 0x99, 0xe0, 0xb0, 0x90, 0x61, 0xfe, 0x46, 0x6b, 0x8b,
0xfc, 0xaf, 0x60, 0x6f, 0x2b, 0xe5, 0x52, 0x7f, 0xa4, 0x73, 0x68, 0x1c, 0xb2, 0xf4, 0x2c, 0x1e,
0x2b, 0xff, 0x04, 0x50, 0x0d, 0x75, 0xe0, 0x39, 0x5a, 0xcc, 0xd5, 0x20, 0xe7, 0xec, 0x93, 0xd1,
0x60, 0xb3, 0xfc, 0xcf, 0xa1, 0x59, 0x80, 0x2f, 0x55, 0xb7, 0x03, 0x2d, 0xb3, 0xd4, 0x08, 0xef,
0xff, 0x51, 0x82, 0xf6, 0x63, 0x36, 0xc6, 0xe6, 0x93, 0x2a, 0x31, 0xfb, 0x50, 0x29, 0xba, 0xf8,
0x4a, 0xb0, 0x46, 0x07, 0x4b, 0x27, 0x9b, 0x24, 0x74, 0x13, 0x5c, 0x12, 0x4e, 0xad, 0x85, 0xd1,
0x46, 0xee, 0x83, 0x70, 0xaa, 0x46, 0x0b, 0x09, 0xd5, 0xf7, 0xaf, 0x70, 0x4a, 0xa2, 0x85, 0xb5,
0xf1, 0xe6, 0xae, 0x58, 0x71, 0x6a, 0x57, 0x9d, 0xe4, 0xff, 0x0c, 0x15, 0x33, 0x22, 0xee, 0x6d,
0x9c, 0x4c, 0xef, 0x55, 0x6a, 0xfe, 0xe7, 0x33, 0xf2, 0x2b, 0xe0, 0x3e, 0x08, 0xa7, 0x7e, 0x0d,
0x2a, 0x5a, 0x56, 0x3e, 0x58, 0xfe, 0x71, 0xa1, 0xa3, 0xcb, 0x8b, 0x39, 0x4b, 0x05, 0x55, 0x87,
0x75, 0x2b, 0xbf, 0x4b, 0x28, 0x75, 0xef, 0x04, 0xeb, 0xb4, 0x12, 0x26, 0x49, 0x9c, 0x52, 0x6e,
0xe6, 0x99, 0xff, 0xa7, 0xab, 0x3f, 0xbb, 0xc1, 0xd0, 0x0d, 0x68, 0x93, 0xf9, 0x3c, 0x89, 0x43,
0xdd, 0xc6, 0x8f, 0x22, 0xab, 0x6e, 0x1d, 0x44, 0xef, 0x01, 0x9c, 0x65, 0x69, 0x68, 0x53, 0xec,
0xa5, 0x6a, 0x85, 0x98, 0x69, 0x60, 0xb7, 0x7c, 0x64, 0x46, 0x99, 0x9e, 0x06, 0x39, 0x84, 0xee,
0x5a, 0x91, 0x65, 0x2d, 0xf2, 0xfd, 0xd7, 0x8a, 0x0c, 0xec, 0xc1, 0x5a, 0xb1, 0xbf, 0x94, 0xa0,
0x66, 0x11, 0x35, 0x90, 0xac, 0xeb, 0x73, 0x99, 0x2b, 0x00, 0xdd, 0xcf, 0x07, 0xb9, 0x2a, 0x70,
0xf3, 0x8d, 0x05, 0x82, 0xc7, 0x71, 0x4a, 0x6d, 0x95, 0xdf, 0x1c, 0x28, 0xab, 0x50, 0x95, 0x90,
0xf1, 0x8c, 0x0a, 0x49, 0x66, 0x73, 0x5d, 0xc2, 0xc5, 0x2b, 0x00, 0x1d, 0x43, 0x55, 0xb0, 0x8c,
0x87, 0xe6, 0x73, 0x75, 0x0e, 0x6e, 0xbd, 0x5d, 0x91, 0x60, 0xa4, 0x17, 0x61, 0xbb, 0x38, 0xbf,
0xfb, 0xb9, 0xab, 0xbb, 0x5f, 0xbf, 0x07, 0x55, 0x93, 0x85, 0x00, 0xaa, 0xa3, 0xe7, 0x47, 0x4f,
0x5f, 0x3c, 0xef, 0xee, 0xd8, 0xe7, 0x63, 0x8c, 0xbb, 0xce, 0xc1, 0x5f, 0x0e, 0x74, 0xcc, 0x78,
0x78, 0xa6, 0xee, 0xc7, 0x21, 0x4b, 0xd0, 0x0d, 0xa8, 0x1e, 0xa7, 0x63, 0xf5, 0xb7, 0x87, 0x20,
0xff, 0xbd, 0xfa, 0x10, 0xe4, 0x3f, 0xc5, 0x81, 0xf3, 0x89, 0x83, 0x6e, 0x43, 0x75, 0xf9, 0x0f,
0x0a, 0xcc, 0x85, 0x3b, 0x58, 0x5e, 0xb8, 0x83, 0x63, 0x75, 0xe1, 0xf6, 0xdb, 0x6b, 0x73, 0x07,
0xed, 0xc3, 0xae, 0xe9, 0xda, 0x8c, 0x53, 0x43, 0xa8, 0xfd, 0x97, 0xc3, 0xc0, 0x6f, 0x07, 0x45,
0xf3, 0xa2, 0x3b, 0x00, 0x23, 0xc9, 0x29, 0x99, 0x3d, 0x66, 0x63, 0x81, 0x3a, 0xeb, 0xde, 0xf0,
0x77, 0x37, 0x8e, 0x48, 0x29, 0x3a, 0xad, 0xea, 0xfa, 0x9f, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff,
0x94, 0x2e, 0xcb, 0x1d, 0x0e, 0x0c, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

12
api/agent/grpc/runner.proto
View File

@@ -45,11 +45,13 @@ message CallFinished {
string createdAt = 5;
string startedAt = 6;
string completedAt = 7;
string image = 8;
int64 schedulerDuration = 9;
int64 executionDuration = 10;
int64 dockerPullWait = 11;
bool errorUser = 12;
int64 schedulerDuration = 8;
int64 executionDuration = 9;
bool errorUser = 10;
string image = 11;
int32 dockerPullRetries = 12;
int64 dockerWaitDuration = 13;
int64 dockerPullDuration = 14;
}
message ClientMsg {

33
api/agent/pure_runner.go
View File

@@ -232,8 +232,12 @@ func (ch *callHandle) enqueueCallResponse(err error) {
var details string
var errCode int
var errStr string
var imageName string
var errUser bool
var nErr error
var dockerPullRetries int32
var dockerPullDuration time.Duration
var dockerWaitDuration time.Duration
log := common.Logger(ch.ctx)
@@ -255,7 +259,10 @@ func (ch *callHandle) enqueueCallResponse(err error) {
if ch.c != nil {
mcall := ch.c.Model()
dockerPullRetries = mcall.DockerPullRetries
dockerPullDuration = mcall.DockerPullDuration
dockerWaitDuration = mcall.DockerWaitDuration
imageName = mcall.Image
// These timestamps are related. To avoid confusion
// and for robustness, nested if stmts below.
if !time.Time(mcall.CreatedAt).IsZero() {
@@ -279,16 +286,20 @@ func (ch *callHandle) enqueueCallResponse(err error) {
errTmp := ch.enqueueMsgStrict(&runner.RunnerMsg{
Body: &runner.RunnerMsg_Finished{Finished: &runner.CallFinished{
Success: nErr == nil,
Details: details,
ErrorCode: int32(errCode),
ErrorStr: errStr,
CreatedAt: createdAt,
StartedAt: startedAt,
CompletedAt: completedAt,
SchedulerDuration: int64(schedulerDuration),
ExecutionDuration: int64(executionDuration),
ErrorUser: errUser,
Success: nErr == nil,
Details: details,
ErrorCode: int32(errCode),
ErrorStr: errStr,
CreatedAt: createdAt,
StartedAt: startedAt,
CompletedAt: completedAt,
SchedulerDuration: int64(schedulerDuration),
ExecutionDuration: int64(executionDuration),
DockerPullDuration: int64(dockerPullDuration),
DockerWaitDuration: int64(dockerWaitDuration),
DockerPullRetries: dockerPullRetries,
Image: imageName,
ErrorUser: errUser,
}}})
if errTmp != nil {

4
api/agent/runner_client.go
View File

@@ -441,7 +441,9 @@ DataLoop:
trace.BoolAttribute("Success", body.Finished.GetSuccess()),
trace.Int64Attribute("ExecutionDuration", body.Finished.GetExecutionDuration()),
trace.Int64Attribute("SchedulerDuration", body.Finished.GetSchedulerDuration()),
trace.Int64Attribute("DockerPullWaitTime", body.Finished.GetDockerWaitTime()),
trace.Int64Attribute("DockerWaitDuration", body.Finished.GetDockerWaitDuration()),
trace.Int64Attribute("DockerPullDuration", body.Finished.GetDockerPullDuration()),
trace.Int64Attribute("DockerPullRetries", int64(body.Finished.GetDockerPullRetries())),
trace.StringAttribute("CompletedAt", body.Finished.GetCompletedAt()),
trace.StringAttribute("CreatedAt", body.Finished.GetCreatedAt()),
trace.StringAttribute("StartedAt", body.Finished.GetStartedAt()),

12
api/models/call.go
View File

@@ -123,9 +123,6 @@ type Call struct {
// Duration that user code was running for, in nanoseconds.
ExecutionDuration time.Duration `json:"execution_duration,omitempty" db:"execution_duration"`
// Duration that image pull has waited, in nanoseconds.
DockerWaitDuration time.Duration `json:"docker_wait_duration,omitempty" db:"docker_wait_duration"`
// Stats is a list of metrics from this call's execution, possibly empty.
Stats stats.Stats `json:"stats,omitempty" db:"stats"`
@@ -144,6 +141,15 @@ type Call struct {
// Fn this call belongs to.
FnID string `json:"fn_id" db:"fn_id"`
// Duration that image pull lasted, in nanoseconds.
DockerWaitDuration time.Duration `json:"docker_wait_duration,omitempty" db:"docker_wait_duration"`
// Duration that the image was actually pulled
DockerPullDuration time.Duration `json:"docker_pull_duration,omitempty" db:"docker_pull_duration"`
// Number of retries when pulling image
DockerPullRetries int32 `json:"docker_pull_retries,omitempty" db:"docker_pull_retries"`
}
type CallFilter struct {

16
api/server/server.go
View File

@@ -859,11 +859,11 @@ func (s *Server) startGears(ctx context.Context, cancel context.CancelFunc) {
Handler: s.Router,
GetStartOptions: func(r *http.Request) trace.StartOptions {
startOptions := trace.StartOptions{}
for _, exclude := range []string{"Prometheus", "kube-probe"} {
if strings.HasPrefix(r.UserAgent(), exclude) {
startOptions.Sampler = trace.NeverSample()
}
// TODO: Add list of url paths to exclude
if r.URL.Path != "/version" {
startOptions.Sampler = trace.AlwaysSample()
}
// Defaults to global sampler
return startOptions
},
}
@@ -894,11 +894,11 @@ func (s *Server) startGears(ctx context.Context, cancel context.CancelFunc) {
Handler: s.AdminRouter,
GetStartOptions: func(r *http.Request) trace.StartOptions {
startOptions := trace.StartOptions{}
for _, exclude := range []string{"Prometheus", "kube-probe"} {
if strings.HasPrefix(r.UserAgent(), exclude) {
startOptions.Sampler = trace.NeverSample()
}
// TODO: Add list of url paths to exclude
if r.URL.Path != "/version" {
startOptions.Sampler = trace.AlwaysSample()
}
// Defaults to global sampler
return startOptions
},
}