// Build builds the image. func (b *Builder) Build(ctx context.Context, w io.Writer, opts builder.BuildOptions) (image string, err error) { log.Printf("Starting build: id=%s repository=%s branch=%s sha=%s", opts.ID, opts.Repository, opts.Branch, opts.Sha, ) // Embed the reporter in the context.Context. ctx = reporter.WithReporter(ctx, b.reporter()) if b.Timeout != 0 { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, b.Timeout) defer cancel() // Release resources. } reporter.AddContext(ctx, "options", opts) defer reporter.Monitor(ctx) defer func() { if err != nil { reporter.Report(ctx, err) } }() image, err = b.builder.Build(ctx, w, opts) return }
// newContext builds a new base Context object. func newContext(c *cli.Context) (ctx *Context, err error) { ctx = &Context{ Context: c, netCtx: context.Background(), } ctx.reporter, err = newReporter(ctx) if err != nil { return } ctx.logger, err = newLogger(ctx) if err != nil { return } ctx.stats, err = newStats(ctx) if err != nil { return } if ctx.reporter != nil { ctx.netCtx = reporter.WithReporter(ctx.netCtx, ctx.reporter) } if ctx.logger != nil { ctx.netCtx = logger.WithLogger(ctx.netCtx, ctx.logger) } if ctx.stats != nil { ctx.netCtx = stats.WithStats(ctx.netCtx, ctx.stats) } return }
// ServeHTTPContext implements the httpx.Handler interface. It recovers from // panics and returns an error for upstream middleware to handle. func (h *Recovery) ServeHTTPContext(ctx context.Context, w http.ResponseWriter, r *http.Request) (err error) { ctx = reporter.WithReporter(ctx, h.Reporter) // Add the request to the context. reporter.AddRequest(ctx, r) // Add the request id reporter.AddContext(ctx, "request_id", httpx.RequestID(ctx)) defer func() { if v := recover(); v != nil { err = fmt.Errorf("%v", v) if v, ok := v.(error); ok { err = v } reporter.Report(ctx, err) return } }() err = h.handler.ServeHTTPContext(ctx, w, r) return }
func Example() { ctx := reporter.WithReporter(context.Background(), hb.NewReporter("dcb8affa")) req, _ := http.NewRequest("GET", "/api/foo", nil) req.Header.Set("Content-Type", "application/json") reporter.AddContext(ctx, "request_id", "1234") reporter.AddRequest(ctx, req) reporter.Report(ctx, errBoom) // Output: }
// newRootContext returns a new root context.Context with an error reporter and // logger embedded in the context. func newRootContext(c *cli.Context) (context.Context, error) { r, err := newReporter(c) if err != nil { return nil, err } l := newLogger() ctx := context.Background() if r != nil { ctx = reporter.WithReporter(ctx, r) } if l != nil { ctx = logger.WithLogger(ctx, l) } return ctx, nil }
// newTestServer returns a new httptest.Server for testing empire's http server. func newTestServer(t testing.TB, e *empire.Empire, opts server.Options) *Server { if e == nil { e = NewEmpire(t) } // Log reporter errors to stderr ctx := reporter.WithReporter(context.Background(), reporter.ReporterFunc(func(ctx context.Context, err error) error { fmt.Fprintf(os.Stderr, "reported error: %v\n", err) return nil })) s := server.New(e, opts) svr := httptest.NewUnstartedServer(middleware.Handler(ctx, s)) u, _ := url.Parse(svr.URL) s.URL = u return &Server{ Empire: e, Server: s, svr: svr, } }