Annotee: Add project name support.

client/logdog/annotee/processor.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package annotee
 
 import (
         "bufio"
         "bytes"
         "fmt"
         "io"
-        "net/url"
         "strings"
         "sync"
         "time"
 
         "github.com/golang/protobuf/proto"
         "github.com/luci/luci-go/client/logdog/annotee/annotation"
         "github.com/luci/luci-go/client/logdog/butlerlib/streamclient"
         "github.com/luci/luci-go/client/logdog/butlerlib/streamproto"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/clockflag"
@@ skipping 40 matching lines @@
         Annotate bool
         // StripAnnotations, if true, causes all encountered annotations to be
         // stripped from incoming stream data.
         StripAnnotations bool
 
         // BufferSize is the size of the read buffer that will be used when processing
         // this stream's data.
         BufferSize int
 }
 
+// LinkGenerator generates links for a given log stream.
+type LinkGenerator interface {
+        // GetLink returns a link for the specified aggregate streams.
+        //
+        // If no link could be generated, GetLink may return an empty string.
+        GetLink(name ...types.StreamName) string
+}
+
 // Options are the configuration options for a Processor.
 type Options struct {
         // Base is the base log stream name. This is prepended to every log name, as
         // well as any generate log names.
         Base types.StreamName
 
-        // Prefix is the log stream prefix. If this is empty, no log stream links will
-        // be generated.
-        Prefix types.StreamName
-
-        // LogDogHost is the host name of the LogDog Coordinator instance that this
-        // stream will be published to. If not empty, additional links will be
-        // injected into the annotation stream to link to the generated LogDog logs.
-        LogDogHost string
+        // LinkGenerator generates links to alias for a given log stream.
+        //
+        // If nil, no link annotations will be injected.
+        LinkGenerator LinkGenerator
 
         // Client is the LogDog Butler Client to use for stream creation.
         Client streamclient.Client
 
         // Execution describes the current applicaton's execution parameters. This
         // will be used to construct annotation state.
         Execution *annotation.Execution
 
         // MetadataUpdateInterval is the amount of time to wait after stream metadata
         // updates to push the updated metadata protobuf to the metadata stream.
@@ skipping 186 matching lines @@
 func (p *Processor) closeStepHandler(h *stepHandler) {
         // Remove this handler from our list. This will stop us from
         // double-finishing when finish() calls Close(), which calls the StepClosed
         // callback.
         delete(p.stepHandlers, h.String())
 
         // Finish the step.
         h.finish()
 }
 
-// coordinatorLink returns a link to the rendered log stream in the Coordinator.
-// If no Coordinator host is configured, this will return an empty string.
-func (p *Processor) coordinatorLink(name ...types.StreamName) string {
-        if p.o.LogDogHost == "" || p.o.Prefix == "" {
-                return ""
-        }
-
-        links := make([]string, len(name))
-        for i, n := range name {
-                links[i] = fmt.Sprintf("s=%s", url.QueryEscape(string(p.o.Prefix.Join(n))))
-        }
-        return fmt.Sprintf("https://%s.appspot.com/v/?%s", p.o.LogDogHost, strings.Join(links, "&"))
-}
-
 type annotationCallbacks struct {
         *Processor
 }
 
 func (c *annotationCallbacks) StepClosed(step *annotation.Step) {
         c.closeStep(step)
 }
 
 func (c *annotationCallbacks) Updated(step *annotation.Step) {
         if h, _ := c.getStepHandler(step, false); h != nil {
@@ skipping 10 matching lines @@
         s, created, err := h.getStream(name, &textStreamArchetype)
         if err != nil {
                 log.Fields{
                         log.ErrorKey: err,
                         "step":       h,
                         "stream":     name,
                 }.Errorf(c.ctx, "Failed to get log substream.")
                 return
         }
         if created {
-                h.maybeInjectCoordinatorLink(label, "logdog", name)
+                h.maybeInjectLink(label, "logdog", name)
         }
 
         if err := writeTextLine(s, line); err != nil {
                 log.Fields{
                         log.ErrorKey: err,
                         "stream":     name,
                 }.Errorf(c.ctx, "Failed to export log line.")
         }
 }
 
@@ skipping 136 matching lines @@
 }
 
 func (h *stepHandler) writeBaseStream(s *Stream, line string) error {
         name := h.step.BaseStream(s.Name)
         stream, created, err := h.getStream(name, &textStreamArchetype)
         if err != nil {
                 return err
         }
         if created {
                 segs := s.Name.Segments()
-                h.maybeInjectCoordinatorLink("stdio", segs[len(segs)-1], name)
+                h.maybeInjectLink("stdio", segs[len(segs)-1], name)
         }
         return writeTextLine(stream, line)
 }
 
 func (h *stepHandler) updated() {
         // Ignore updates after the step has closed.
         if h.closed {
                 return
         }
 
@@ skipping 68 matching lines @@
                 return nil
         }
 
         lines := make([]string, len(h.injectedLines))
         copy(lines, h.injectedLines)
         h.injectedLines = h.injectedLines[:0]
 
         return lines
 }
 
-func (h *stepHandler) injectAliasAnnotation(base, text, url string) {
-        h.injectLines(buildAnnotation("STEP_LINK", fmt.Sprintf("%s-->%s", text, base), url))
-}
-
-func (h *stepHandler) maybeInjectCoordinatorLink(base, text string, names ...types.StreamName) {
-        url := h.processor.coordinatorLink(names...)
-        if url == "" {
-                return
+func (h *stepHandler) maybeInjectLink(base, text string, names ...types.StreamName) {
+        if lg := h.processor.o.LinkGenerator; lg != nil {
+                if link := lg.GetLink(names...); link != "" {
+                        h.injectLines(buildAnnotation("STEP_LINK", fmt.Sprintf("%s-->%s", text, base), link))
+                }
         }
-        h.injectAliasAnnotation(base, text, url)
 }
 
 // lineReader reads from an input stream and returns the data line-by-line.
 //
 // We don't use a Scanner because we want to be able to handle lines that may
 // exceed the buffer length. We don't use ReadBytes here because we need to
 // capture the last line in the stream, even if it doesn't end with a newline.
 type lineReader struct {
         r   *bufio.Reader
         buf bytes.Buffer
@@ skipping 31 matching lines @@
                 return ""
         }
         return strings.TrimSpace(line[3 : len(line)-3])
 }
 
 func buildAnnotation(name string, params ...string) string {
         v := make([]string, 1, 1+len(params))
         v[0] = name
         return "@@@" + strings.Join(append(v, params...), "@") + "@@@"
 }