func TestSpanStatsGRPCResponse(t *testing.T) { defer leaktest.AfterTest(t)() ts := startServer(t) defer ts.Stopper().Stop() rpcStopper := stop.NewStopper() defer rpcStopper.Stop() rpcContext := rpc.NewContext(log.AmbientContext{}, ts.RPCContext().Config, ts.Clock(), rpcStopper) request := serverpb.SpanStatsRequest{ NodeID: "1", StartKey: []byte(roachpb.RKeyMin), EndKey: []byte(roachpb.RKeyMax), } url := ts.ServingAddr() conn, err := rpcContext.GRPCDial(url) if err != nil { t.Fatal(err) } client := serverpb.NewStatusClient(conn) response, err := client.SpanStats(context.Background(), &request) if err != nil { t.Fatal(err) } if a, e := int(response.RangeCount), ExpectedInitialRangeCount(); a != e { t.Errorf("expected %d ranges, found %d", e, a) } }
func TestSpanStatsResponse(t *testing.T) { defer leaktest.AfterTest(t)() ts := startServer(t) defer ts.Stopper().Stop() httpClient, err := ts.GetHTTPClient() if err != nil { t.Fatal(err) } var response serverpb.SpanStatsResponse request := serverpb.SpanStatsRequest{ NodeID: "1", StartKey: []byte(roachpb.RKeyMin), EndKey: []byte(roachpb.RKeyMax), } url := ts.AdminURL() + statusPrefix + "span" if err := httputil.PostJSON(httpClient, url, &request, &response); err != nil { t.Fatal(err) } if a, e := int(response.RangeCount), ExpectedInitialRangeCount(); a != e { t.Errorf("expected %d ranges, found %d", e, a) } }
func TestRangesResponse(t *testing.T) { defer leaktest.AfterTest(t)() ts := startServer(t) defer ts.Stopper().Stop() // Perform a scan to ensure that all the raft groups are initialized. if _, err := ts.db.Scan(context.TODO(), keys.LocalMax, roachpb.KeyMax, 0); err != nil { t.Fatal(err) } var response serverpb.RangesResponse if err := getStatusJSONProto(ts, "ranges/local", &response); err != nil { t.Fatal(err) } if len(response.Ranges) == 0 { t.Errorf("didn't get any ranges") } for _, ri := range response.Ranges { // Do some simple validation based on the fact that this is a // single-node cluster. if ri.RaftState.State != "StateLeader" && ri.RaftState.State != "StateDormant" { t.Errorf("expected to be Raft leader or dormant, but was '%s'", ri.RaftState.State) } expReplica := roachpb.ReplicaDescriptor{ NodeID: 1, StoreID: 1, ReplicaID: 1, } if len(ri.State.Desc.Replicas) != 1 || ri.State.Desc.Replicas[0] != expReplica { t.Errorf("unexpected replica list %+v", ri.State.Desc.Replicas) } if ri.State.Lease == nil { t.Error("expected a nontrivial Lease") } if ri.State.LastIndex == 0 { t.Error("expected positive LastIndex") } } }
// TestStatusLocalLogs checks to ensure that local/logfiles, // local/logfiles/{filename}, local/log and local/log/{level} function // correctly. func TestStatusLocalLogs(t *testing.T) { defer leaktest.AfterTest(t)() if log.V(3) { t.Skip("Test only works with low verbosity levels") } dir, err := ioutil.TempDir("", "local_log_test") if err != nil { t.Fatal(err) } if err := log.EnableLogFileOutput(dir); err != nil { t.Fatal(err) } defer func() { log.DisableLogFileOutput() if err := os.RemoveAll(dir); err != nil { t.Fatal(err) } }() ts := startServer(t) defer ts.Stopper().Stop() // Log an error which we expect to show up on every log file. timestamp := timeutil.Now().UnixNano() log.Errorf(context.Background(), "TestStatusLocalLogFile test message-Error") timestampE := timeutil.Now().UnixNano() log.Warningf(context.Background(), "TestStatusLocalLogFile test message-Warning") timestampEW := timeutil.Now().UnixNano() log.Infof(context.Background(), "TestStatusLocalLogFile test message-Info") timestampEWI := timeutil.Now().UnixNano() var wrapper serverpb.LogFilesListResponse if err := getStatusJSONProto(ts, "logfiles/local", &wrapper); err != nil { t.Fatal(err) } if a, e := len(wrapper.Files), 3; a != e { t.Fatalf("expected %d log files; got %d", e, a) } for i, name := range []string{"log.ERROR", "log.INFO", "log.WARNING"} { if !strings.Contains(wrapper.Files[i].Name, name) { t.Errorf("expected log file name %s to contain %q", wrapper.Files[i].Name, name) } } // Check each individual log can be fetched and is non-empty. var foundInfo, foundWarning, foundError bool for _, file := range wrapper.Files { var wrapper serverpb.LogEntriesResponse if err := getStatusJSONProto(ts, "logfiles/local/"+file.Name, &wrapper); err != nil { t.Fatal(err) } for _, entry := range wrapper.Entries { switch entry.Message { case "TestStatusLocalLogFile test message-Error": foundError = true case "TestStatusLocalLogFile test message-Warning": foundWarning = true case "TestStatusLocalLogFile test message-Info": foundInfo = true } } } if !(foundInfo && foundWarning && foundError) { t.Errorf("expected to find test messages in %v", wrapper.Files) } type levelPresence struct { Error, Warning, Info bool } testCases := []struct { Level log.Severity MaxEntities int StartTimestamp int64 EndTimestamp int64 Pattern string levelPresence }{ // Test filtering by log severity. {log.Severity_INFO, 0, 0, 0, "", levelPresence{true, true, true}}, {log.Severity_WARNING, 0, 0, 0, "", levelPresence{true, true, false}}, {log.Severity_ERROR, 0, 0, 0, "", levelPresence{true, false, false}}, // // Test entry limit. Ignore Info/Warning/Error filters. {log.Severity_INFO, 1, timestamp, timestampEWI, "", levelPresence{false, false, false}}, {log.Severity_INFO, 2, timestamp, timestampEWI, "", levelPresence{false, false, false}}, {log.Severity_INFO, 3, timestamp, timestampEWI, "", levelPresence{false, false, false}}, // Test filtering in different timestamp windows. {log.Severity_INFO, 0, timestamp, timestamp, "", levelPresence{false, false, false}}, {log.Severity_INFO, 0, timestamp, timestampE, "", levelPresence{true, false, false}}, {log.Severity_INFO, 0, timestampE, timestampEW, "", levelPresence{false, true, false}}, {log.Severity_INFO, 0, timestampEW, timestampEWI, "", levelPresence{false, false, true}}, {log.Severity_INFO, 0, timestamp, timestampEW, "", levelPresence{true, true, false}}, {log.Severity_INFO, 0, timestampE, timestampEWI, "", levelPresence{false, true, true}}, {log.Severity_INFO, 0, timestamp, timestampEWI, "", levelPresence{true, true, true}}, // Test filtering by regexp pattern. {log.Severity_INFO, 0, 0, 0, "Info", levelPresence{false, false, true}}, {log.Severity_INFO, 0, 0, 0, "Warning", levelPresence{false, true, false}}, {log.Severity_INFO, 0, 0, 0, "Error", levelPresence{true, false, false}}, {log.Severity_INFO, 0, 0, 0, "Info|Error|Warning", levelPresence{true, true, true}}, {log.Severity_INFO, 0, 0, 0, "Nothing", levelPresence{false, false, false}}, } for i, testCase := range testCases { var url bytes.Buffer fmt.Fprintf(&url, "logs/local?level=%s", testCase.Level.Name()) if testCase.MaxEntities > 0 { fmt.Fprintf(&url, "&max=%d", testCase.MaxEntities) } if testCase.StartTimestamp > 0 { fmt.Fprintf(&url, "&start_time=%d", testCase.StartTimestamp) } if testCase.StartTimestamp > 0 { fmt.Fprintf(&url, "&end_time=%d", testCase.EndTimestamp) } if len(testCase.Pattern) > 0 { fmt.Fprintf(&url, "&pattern=%s", testCase.Pattern) } var wrapper serverpb.LogEntriesResponse path := url.String() if err := getStatusJSONProto(ts, path, &wrapper); err != nil { t.Fatal(err) } if testCase.MaxEntities > 0 { if a, e := len(wrapper.Entries), testCase.MaxEntities; a != e { t.Errorf("%d expected %d entries, got %d: \n%+v", i, e, a, wrapper.Entries) } } else { var actual levelPresence var logsBuf bytes.Buffer for _, entry := range wrapper.Entries { fmt.Fprintln(&logsBuf, entry.Message) switch entry.Message { case "TestStatusLocalLogFile test message-Error": actual.Error = true case "TestStatusLocalLogFile test message-Warning": actual.Warning = true case "TestStatusLocalLogFile test message-Info": actual.Info = true } } if testCase.levelPresence != actual { t.Errorf("%d: expected %+v at %s, got:\n%s", i, testCase, path, logsBuf.String()) } } } }