garnet

1
// Copyright (c) Microsoft Corporation.
2
// Licensed under the MIT license.
3

4
using System;
5
using System.Collections.Generic;
6
using System.Linq;
7
using System.Net;
8
using System.Threading;
9
using StackExchange.Redis;
10

11
namespace MetricsMonitor
12
{
13
    public class ClientMonitor
14
    {
15
        IConnectionMultiplexer connectionMultiplexer;
16
        Options opts;
17
        ClusterConfiguration clusterConfig;
18

19
        public ClientMonitor(Options opts)
20
        {
21
            this.opts = opts;
22
            connectionMultiplexer = ConnectionMultiplexer.Connect(
23
                Configuration.GetConfig(opts.Address, opts.Port, useTLS: opts.EnableTLS, tlsHost: opts.TlsHost, allowAdmin: true));
24
            if (opts.Cluster)
25
                clusterConfig = GetClusterConfig();
26
        }
27

28
        private ClusterConfiguration GetClusterConfig()
29
        {
30
            var clusterConfig = connectionMultiplexer.GetServer(opts.Address + ":" + opts.Port).ClusterNodes();
31
            return clusterConfig;
32
        }
33

34
        public void StartMonitor()
35
        {
36
            if (opts.Cluster)
37
            {
38
                if (opts.MetricsType == Metric.LATENCY)
39
                    MonitorClusterLatencyMetrics();
40
                else if (opts.MetricsType == Metric.INFO)
41
                    MonitorClusterServerSideMetrics();
42
            }
43
            else
44
            {
45
                if (opts.MetricsType == Metric.LATENCY)
46
                    MonitorServerSideLatency();
47
                else if (opts.MetricsType == Metric.INFO)
48
                    MonitorServerSideMetrics();
49
            }
50
        }
51

52
        public void MonitorServerSideLatency()
53
        {
54
            var db = connectionMultiplexer.GetDatabase(0);
55
            string eventStr = opts.LatencyEvent.ToString();
56
            Console.WriteLine("Reseting histogram..");
57
            var reset = db.Execute("latency", "reset", "command");
58
            //Wait for async reset
59
            Thread.Sleep(1000);
60
            List<object> cmdArgs = new List<object>()
61
            {
62
                "histogram",
63
                eventStr
64
            };
65
            int iter = 0;
66
            Console.WriteLine($"[Capturing server side latency metrics for event ({opts.LatencyEvent}) using client]");
67
            while (true)
68
            {
69
                RedisResult[] resp = (RedisResult[])db.Execute("latency", cmdArgs);
70
                ProcessLatencyHistogram(resp, ref iter);
71
                Thread.Sleep(TimeSpan.FromSeconds(opts.Poll));
72
            }
73
        }
74

75
        private static bool ProcessLatencyHistogram(RedisResult[] resp, ref int iter)
76
        {
77
            if (resp.Length != 2)
78
                return false;
79

80
            string name = (string)resp[0];
81
            RedisResult[] info = (RedisResult[])resp[1];
82

83
            if (info.Length != 6)
84
                return false;
85

86
            int calls = Int32.Parse((string)info[1]);
87
            string units = (string)info[2];
88
            RedisResult[] latency = (RedisResult[])info[5];
89

90
            if (latency.Length != 14)
91
                return false;
92

93
            if (iter++ == 0)
94
                Console.WriteLine($"{latency[0]} (us); {latency[2]} (us); {latency[4]} (us); {latency[6]} (us); {latency[8]} (us); {latency[10]} (us); {latency[12]} (us); cnt");
95

96
            Console.WriteLine("{0:0.0}; {1:0.0}; {2:0.0}; {3:0.0}; {4:0.0}; {5:0.0}; {6:0.0}; {7}",
97
                latency[1],
98
                latency[3],
99
                latency[5],
100
                latency[7],
101
                latency[9],
102
                latency[11],
103
                latency[13],
104
                calls);
105

106
            return true;
107
        }
108

109
        public void MonitorServerSideMetrics()
110
        {
111
            var db = connectionMultiplexer.GetDatabase(0);
112
            var infoType = opts.infoType;
113
            Console.WriteLine($"[Capturing server side metrics for event ({infoType}) using client]");
114
            while (true)
115
            {
116
                var resp = db.Execute("info", infoType.ToString());
117
                connectionMultiplexer.GetEndPoints();
118
                Console.WriteLine((string)resp);
119
                Thread.Sleep(TimeSpan.FromSeconds(opts.Poll));
120
            }
121
        }
122

123
        public void MonitorClusterServerSideMetrics()
124
        {
125
            var nodes = clusterConfig?.Nodes.ToArray();
126
            var infoType = opts.infoType;
127
            Console.WriteLine($"[Capturing server side metrics for event ({infoType}) using client]");
128

129
            while (true)
130
            {
131
                for (int i = 0; i < nodes.Length; i++)
132
                {
133
                    var endpoint = (IPEndPoint)nodes[i].EndPoint;
134
                    Console.WriteLine($"<<< {endpoint.Address}:{endpoint.Port} >>>");
135
                    var server = connectionMultiplexer.GetServer(endpoint);
136
                    var info = server.Info(infoType.ToString());
137
                    foreach (var group in info)
138
                    {
139
                        var key = group.Key;
140
                        foreach (var pair in group)
141
                        {
142
                            Console.WriteLine($"{pair.Key}:{pair.Value}");
143
                        }
144
                    }
145
                    Console.WriteLine();
146
                }
147
                Thread.Sleep(TimeSpan.FromSeconds(opts.Poll));
148
            }
149
        }
150

151
        public void MonitorClusterLatencyMetrics()
152
        {
153
            var nodes = clusterConfig?.Nodes.ToArray();
154
            var latencyType = opts.LatencyEvent;
155
            Console.WriteLine($"[Capturing server side latency metrics for event ({latencyType}) using client]");
156

157
            List<object> cmdArgs = new List<object>()
158
            {
159
                "histogram",
160
                latencyType.ToString(),
161
            };
162
            int iter = 1;
163
            while (true)
164
            {
165
                for (int i = 0; i < nodes.Length; i++)
166
                {
167
                    var endpoint = (IPEndPoint)nodes[i].EndPoint;
168
                    Console.WriteLine($"<<< {endpoint.Address}:{endpoint.Port} >>>");
169
                    var server = connectionMultiplexer.GetServer(endpoint);
170
                    RedisResult[] resp = (RedisResult[])server.Execute("latency", cmdArgs);
171
                    ProcessLatencyHistogram(resp, ref iter);
172
                    Console.WriteLine();
173
                }
174
                Thread.Sleep(TimeSpan.FromSeconds(opts.Poll));
175
            }
176
        }
177

178

179
    }
180
}