forked from jaegertracing/jaeger
-
Notifications
You must be signed in to change notification settings - Fork 0
/
redis.go
114 lines (101 loc) · 3.35 KB
/
redis.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// Copyright (c) 2017 Uber Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package driver
import (
"context"
"errors"
"fmt"
"math/rand"
"sync"
"github.com/opentracing/opentracing-go"
"github.com/opentracing/opentracing-go/ext"
"github.com/uber/jaeger-lib/metrics"
"go.uber.org/zap"
"github.com/jaegertracing/jaeger/examples/hotrod/pkg/delay"
"github.com/jaegertracing/jaeger/examples/hotrod/pkg/log"
"github.com/jaegertracing/jaeger/examples/hotrod/pkg/tracing"
"github.com/jaegertracing/jaeger/examples/hotrod/services/config"
)
// Redis is a simulator of remote Redis cache
type Redis struct {
tracer opentracing.Tracer // simulate redis as a separate process
logger log.Factory
errorSimulator
}
func newRedis(metricsFactory metrics.Factory, logger log.Factory) *Redis {
return &Redis{
tracer: tracing.Init("redis", metricsFactory, logger),
logger: logger,
}
}
// FindDriverIDs finds IDs of drivers who are near the location.
func (r *Redis) FindDriverIDs(ctx context.Context, location string) []string {
if span := opentracing.SpanFromContext(ctx); span != nil {
span := r.tracer.StartSpan("FindDriverIDs", opentracing.ChildOf(span.Context()))
span.SetTag("param.location", location)
ext.SpanKindRPCClient.Set(span)
defer span.Finish()
ctx = opentracing.ContextWithSpan(ctx, span)
}
// simulate RPC delay
delay.Sleep(config.RedisFindDelay, config.RedisFindDelayStdDev)
drivers := make([]string, 10)
for i := range drivers {
// #nosec
drivers[i] = fmt.Sprintf("T7%05dC", rand.Int()%100000)
}
r.logger.For(ctx).Info("Found drivers", zap.Strings("drivers", drivers))
return drivers
}
// GetDriver returns driver and the current car location
func (r *Redis) GetDriver(ctx context.Context, driverID string) (Driver, error) {
if span := opentracing.SpanFromContext(ctx); span != nil {
span := r.tracer.StartSpan("GetDriver", opentracing.ChildOf(span.Context()))
span.SetTag("param.driverID", driverID)
ext.SpanKindRPCClient.Set(span)
defer span.Finish()
ctx = opentracing.ContextWithSpan(ctx, span)
}
// simulate RPC delay
delay.Sleep(config.RedisGetDelay, config.RedisGetDelayStdDev)
if err := r.checkError(); err != nil {
if span := opentracing.SpanFromContext(ctx); span != nil {
ext.Error.Set(span, true)
}
r.logger.For(ctx).Error("redis timeout", zap.String("driver_id", driverID), zap.Error(err))
return Driver{}, err
}
// #nosec
return Driver{
DriverID: driverID,
Location: fmt.Sprintf("%d,%d", rand.Int()%1000, rand.Int()%1000),
}, nil
}
var errTimeout = errors.New("redis timeout")
type errorSimulator struct {
sync.Mutex
countTillError int
}
func (es *errorSimulator) checkError() error {
es.Lock()
es.countTillError--
if es.countTillError > 0 {
es.Unlock()
return nil
}
es.countTillError = 5
es.Unlock()
delay.Sleep(2*config.RedisGetDelay, 0) // add more delay for "timeout"
return errTimeout
}