func (s *Span) Collect() error { log.Debugf("[Zipkin] Sending spans: %b", s.sampled) if !s.sampled { return nil } log.Debugf("[Zipkin] Serializing span: %v", s.span) bytes, err := SerializeSpan(s.span) if err != nil { return err } s.collector.Collect(bytes) return nil }
func (s *Span) NewChild(name string) *Span { log.Debugf("[Zipkin] Creating new child span: %s", name) if !s.sampled { return &Span{} } child := newSpan(name, s.span.TraceID, newID(), &s.span.ID, s.serviceName) child.collector = s.collector child.ip = s.ip child.port = s.port child.sampled = true return child }
func (t *Tracer) NewSpan(name string) *Span { log.Debugf("[Zipkin] Creating new span: %s", name) sampled := rand.Intn(t.rate) == 0 if !sampled { return &Span{sampled: false} } span := newSpan(name, newID(), newID(), nil, t.serviceName) span.collector = t.collector span.port = t.port span.ip = t.ip span.sampled = true return span }
func (sc *ServerCommand) connectMarathon(url string, retries int, backoff time.Duration) (marathon.Marathon, error) { var err error var marathonClient marathon.Marathon for i := 0; i < retries; i++ { log.Infof("Trying to connect to Marathon: attempt %d", i) marathonClient, err = sc.newMarathonClient(url) if err == nil { return marathonClient, nil } log.Debugf("Error: %s", err) time.Sleep(backoff) } return nil, err }
func (t *Tracer) NewSpanFromRequest(name string, traceId *int64, spanId *int64, parentId *int64, sampled *bool) *Span { nonSampled := &Span{sampled: false} if sampled == nil { log.Debugf("[Zipkin] Empty trace info provided. Ignoring") return nonSampled } if !*sampled { log.Debugf("[Zipkin] The input trace info not sampled. Ignoring") return nonSampled } if spanId == nil || traceId == nil { log.Debugf("[Zipkin] The input trace info incomplete. Ignoring") return nonSampled } log.Debugf("[Zipkin] Creating new span %s from request: traceID %s, spanID %s, parentID %s, sampled %s", name, traceId, spanId, parentId, sampled) span := newSpan(name, *traceId, *spanId, nil, t.serviceName) span.collector = t.collector span.port = t.port span.ip = t.ip span.sampled = true return span }
func (sc *ServerCommand) Bootstrap(stackFile string, marathonClient marathon.Marathon, scheduler framework.Scheduler, retries int, backoff time.Duration) (*framework.Variables, error) { stackFileData, err := ioutil.ReadFile(stackFile) if err != nil { log.Errorf("Can't read file %s", stackFile) return nil, err } stack, err := framework.UnmarshalStack(stackFileData) if err != nil { return nil, err } log.Debugf("Boostrapping with stack: \n%s", string(stackFileData)) bootstrapZone := "" context := framework.NewRunContext(framework.NewVariables()) context.StackName = stack.Name context.Zone = bootstrapZone context.Marathon = marathonClient context.Scheduler = scheduler context.StateStorage = framework.NewInMemoryStateStorage() for i := 0; i < retries; i++ { err = stack.Run(&framework.RunRequest{ Zone: bootstrapZone, MaxWait: defaultApplicationMaxWait, }, context) if err == nil { return context.Variables, nil } if err != nil && !regexp.MustCompile(marathon.ErrMarathonDown.Error()).MatchString(err.Error()) { return nil, err } time.Sleep(backoff) } return context.Variables, err }
func (s *Span) ClientReceive() { log.Debugf("[Zipkin] ClientReceive") s.Annotate(zipkincore.CLIENT_RECV) }
func (s *Span) ClientSend() { log.Debugf("[Zipkin] ClientSend") s.Annotate(zipkincore.CLIENT_SEND) }
func (s *Span) ServerSend() { log.Debugf("[Zipkin] ServerSend") s.Annotate(zipkincore.SERVER_SEND) }
func (s *Span) ServerReceive() { log.Debugf("[Zipkin] ServerReceive") s.Annotate(zipkincore.SERVER_RECV) }
func (kc *KafkaCollector) Collect(bytes []byte) { log.Debugf("[Zipkin] Collecting bytes: %v", bytes) kc.producer.Send(&producer.ProducerRecord{Topic: kc.topic, Value: bytes}) log.Debugf("[Zipkin] Bytes collected") }