end_to_end_test.go

Documentation: go.opencensus.io/plugin/ocgrpc

     1  // Copyright 2018, OpenCensus Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  //
    15  
    16  package ocgrpc_test
    17  
    18  import (
    19  	"context"
    20  	"io"
    21  	"reflect"
    22  	"testing"
    23  
    24  	"go.opencensus.io/internal/testpb"
    25  	"go.opencensus.io/plugin/ocgrpc"
    26  	"go.opencensus.io/stats/view"
    27  	"go.opencensus.io/tag"
    28  )
    29  
    30  var keyAccountId = tag.MustNewKey("account_id")
    31  
    32  func TestEndToEnd_Single(t *testing.T) {
    33  	view.Register(ocgrpc.DefaultClientViews...)
    34  	defer view.Unregister(ocgrpc.DefaultClientViews...)
    35  	view.Register(ocgrpc.DefaultServerViews...)
    36  	defer view.Unregister(ocgrpc.DefaultServerViews...)
    37  
    38  	extraViews := []*view.View{
    39  		ocgrpc.ServerReceivedMessagesPerRPCView,
    40  		ocgrpc.ClientReceivedMessagesPerRPCView,
    41  		ocgrpc.ServerSentMessagesPerRPCView,
    42  		ocgrpc.ClientSentMessagesPerRPCView,
    43  		ocgrpc.ServerStartedRPCsView,
    44  		ocgrpc.ClientStartedRPCsView,
    45  	}
    46  	view.Register(extraViews...)
    47  	defer view.Unregister(extraViews...)
    48  
    49  	client, done := testpb.NewTestClient(t)
    50  	defer done()
    51  
    52  	ctx := context.Background()
    53  	ctx, _ = tag.New(ctx, tag.Insert(keyAccountId, "abc123"))
    54  
    55  	var (
    56  		clientMethodTag        = tag.Tag{Key: ocgrpc.KeyClientMethod, Value: "testpb.Foo/Single"}
    57  		serverMethodTag        = tag.Tag{Key: ocgrpc.KeyServerMethod, Value: "testpb.Foo/Single"}
    58  		clientStatusOKTag      = tag.Tag{Key: ocgrpc.KeyClientStatus, Value: "OK"}
    59  		serverStatusOKTag      = tag.Tag{Key: ocgrpc.KeyServerStatus, Value: "OK"}
    60  		serverStatusUnknownTag = tag.Tag{Key: ocgrpc.KeyClientStatus, Value: "UNKNOWN"}
    61  		clientStatusUnknownTag = tag.Tag{Key: ocgrpc.KeyServerStatus, Value: "UNKNOWN"}
    62  	)
    63  
    64  	_, err := client.Single(ctx, &testpb.FooRequest{})
    65  	if err != nil {
    66  		t.Fatal(err)
    67  	}
    68  	checkCount(t, ocgrpc.ClientStartedRPCsView, 1, clientMethodTag)
    69  	checkCount(t, ocgrpc.ServerStartedRPCsView, 1, serverMethodTag)
    70  	checkCount(t, ocgrpc.ClientCompletedRPCsView, 1, clientMethodTag, clientStatusOKTag)
    71  	checkCount(t, ocgrpc.ServerCompletedRPCsView, 1, serverMethodTag, serverStatusOKTag)
    72  
    73  	_, _ = client.Single(ctx, &testpb.FooRequest{Fail: true})
    74  	checkCount(t, ocgrpc.ClientStartedRPCsView, 2, clientMethodTag)
    75  	checkCount(t, ocgrpc.ServerStartedRPCsView, 2, serverMethodTag)
    76  	checkCount(t, ocgrpc.ClientCompletedRPCsView, 1, clientMethodTag, serverStatusUnknownTag)
    77  	checkCount(t, ocgrpc.ServerCompletedRPCsView, 1, serverMethodTag, clientStatusUnknownTag)
    78  
    79  	tcs := []struct {
    80  		v    *view.View
    81  		tags []tag.Tag
    82  		mean float64
    83  	}{
    84  		{ocgrpc.ClientSentMessagesPerRPCView, []tag.Tag{clientMethodTag}, 1.0},
    85  		{ocgrpc.ServerReceivedMessagesPerRPCView, []tag.Tag{serverMethodTag}, 1.0},
    86  		{ocgrpc.ClientReceivedMessagesPerRPCView, []tag.Tag{clientMethodTag}, 0.5},
    87  		{ocgrpc.ServerSentMessagesPerRPCView, []tag.Tag{serverMethodTag}, 0.5},
    88  		{ocgrpc.ClientSentBytesPerRPCView, []tag.Tag{clientMethodTag}, 1.0},
    89  		{ocgrpc.ServerReceivedBytesPerRPCView, []tag.Tag{serverMethodTag}, 1.0},
    90  		{ocgrpc.ClientReceivedBytesPerRPCView, []tag.Tag{clientMethodTag}, 0.0},
    91  		{ocgrpc.ServerSentBytesPerRPCView, []tag.Tag{serverMethodTag}, 0.0},
    92  	}
    93  
    94  	for _, tt := range tcs {
    95  		t.Run("view="+tt.v.Name, func(t *testing.T) {
    96  			dist := getDistribution(t, tt.v, tt.tags...)
    97  			if got, want := dist.Count, int64(2); got != want {
    98  				t.Errorf("Count = %d; want %d", got, want)
    99  			}
   100  			if got, want := dist.Mean, tt.mean; got != want {
   101  				t.Errorf("Mean = %v; want %v", got, want)
   102  			}
   103  		})
   104  	}
   105  }
   106  
   107  func TestEndToEnd_Stream(t *testing.T) {
   108  	view.Register(ocgrpc.DefaultClientViews...)
   109  	defer view.Unregister(ocgrpc.DefaultClientViews...)
   110  
   111  	view.Register(ocgrpc.DefaultServerViews...)
   112  	defer view.Unregister(ocgrpc.DefaultServerViews...)
   113  
   114  	extraViews := []*view.View{
   115  		ocgrpc.ServerReceivedMessagesPerRPCView,
   116  		ocgrpc.ClientReceivedMessagesPerRPCView,
   117  		ocgrpc.ServerSentMessagesPerRPCView,
   118  		ocgrpc.ClientSentMessagesPerRPCView,
   119  		ocgrpc.ClientStartedRPCsView,
   120  		ocgrpc.ServerStartedRPCsView,
   121  	}
   122  	view.Register(extraViews...)
   123  	defer view.Unregister(extraViews...)
   124  
   125  	client, done := testpb.NewTestClient(t)
   126  	defer done()
   127  
   128  	ctx := context.Background()
   129  	ctx, _ = tag.New(ctx, tag.Insert(keyAccountId, "abc123"))
   130  
   131  	var (
   132  		clientMethodTag   = tag.Tag{Key: ocgrpc.KeyClientMethod, Value: "testpb.Foo/Multiple"}
   133  		serverMethodTag   = tag.Tag{Key: ocgrpc.KeyServerMethod, Value: "testpb.Foo/Multiple"}
   134  		clientStatusOKTag = tag.Tag{Key: ocgrpc.KeyClientStatus, Value: "OK"}
   135  		serverStatusOKTag = tag.Tag{Key: ocgrpc.KeyServerStatus, Value: "OK"}
   136  	)
   137  
   138  	const msgCount = 3
   139  
   140  	stream, err := client.Multiple(ctx)
   141  	if err != nil {
   142  		t.Fatal(err)
   143  	}
   144  	for i := 0; i < msgCount; i++ {
   145  		stream.Send(&testpb.FooRequest{})
   146  		_, err := stream.Recv()
   147  		if err != nil {
   148  			t.Fatal(err)
   149  		}
   150  	}
   151  	if err := stream.CloseSend(); err != nil {
   152  		t.Fatal(err)
   153  	}
   154  	if _, err = stream.Recv(); err != io.EOF {
   155  		t.Fatal(err)
   156  	}
   157  
   158  	checkCount(t, ocgrpc.ClientStartedRPCsView, 1, clientMethodTag)
   159  	checkCount(t, ocgrpc.ServerStartedRPCsView, 1, serverMethodTag)
   160  	checkCount(t, ocgrpc.ClientCompletedRPCsView, 1, clientMethodTag, clientStatusOKTag)
   161  	checkCount(t, ocgrpc.ServerCompletedRPCsView, 1, serverMethodTag, serverStatusOKTag)
   162  
   163  	tcs := []struct {
   164  		v   *view.View
   165  		tag tag.Tag
   166  	}{
   167  		{ocgrpc.ClientSentMessagesPerRPCView, clientMethodTag},
   168  		{ocgrpc.ServerReceivedMessagesPerRPCView, serverMethodTag},
   169  		{ocgrpc.ServerSentMessagesPerRPCView, serverMethodTag},
   170  		{ocgrpc.ClientReceivedMessagesPerRPCView, clientMethodTag},
   171  	}
   172  	for _, tt := range tcs {
   173  		serverSent := getDistribution(t, tt.v, tt.tag)
   174  		if got, want := serverSent.Mean, float64(msgCount); got != want {
   175  			t.Errorf("%q.Count = %v; want %v", ocgrpc.ServerSentMessagesPerRPCView.Name, got, want)
   176  		}
   177  	}
   178  }
   179  
   180  func checkCount(t *testing.T, v *view.View, want int64, tags ...tag.Tag) {
   181  	if got, ok := getCount(t, v, tags...); ok && got != want {
   182  		t.Errorf("View[name=%q].Row[tags=%v].Data = %d; want %d", v.Name, tags, got, want)
   183  	}
   184  }
   185  
   186  func getCount(t *testing.T, v *view.View, tags ...tag.Tag) (int64, bool) {
   187  	if len(tags) != len(v.TagKeys) {
   188  		t.Errorf("Invalid tag specification, want %#v tags got %#v", v.TagKeys, tags)
   189  		return 0, false
   190  	}
   191  	for i := range v.TagKeys {
   192  		if tags[i].Key != v.TagKeys[i] {
   193  			t.Errorf("Invalid tag specification, want %#v tags got %#v", v.TagKeys, tags)
   194  			return 0, false
   195  		}
   196  	}
   197  
   198  	rows, err := view.RetrieveData(v.Name)
   199  	if err != nil {
   200  		t.Fatal(err)
   201  	}
   202  	var foundRow *view.Row
   203  	for _, row := range rows {
   204  		if reflect.DeepEqual(row.Tags, tags) {
   205  			foundRow = row
   206  			break
   207  		}
   208  	}
   209  	if foundRow == nil {
   210  		var gotTags [][]tag.Tag
   211  		for _, row := range rows {
   212  			gotTags = append(gotTags, row.Tags)
   213  		}
   214  		t.Errorf("Failed to find row with keys %v among:\n%v", tags, gotTags)
   215  		return 0, false
   216  	}
   217  	return foundRow.Data.(*view.CountData).Value, true
   218  }
   219  
   220  func getDistribution(t *testing.T, v *view.View, tags ...tag.Tag) *view.DistributionData {
   221  	if len(tags) != len(v.TagKeys) {
   222  		t.Fatalf("Invalid tag specification, want %#v tags got %#v", v.TagKeys, tags)
   223  		return nil
   224  	}
   225  	for i := range v.TagKeys {
   226  		if tags[i].Key != v.TagKeys[i] {
   227  			t.Fatalf("Invalid tag specification, want %#v tags got %#v", v.TagKeys, tags)
   228  			return nil
   229  		}
   230  	}
   231  	rows, err := view.RetrieveData(v.Name)
   232  	if err != nil {
   233  		t.Fatal(err)
   234  	}
   235  	var foundRow *view.Row
   236  	for _, row := range rows {
   237  		if reflect.DeepEqual(row.Tags, tags) {
   238  			foundRow = row
   239  			break
   240  		}
   241  	}
   242  	if foundRow == nil {
   243  		var gotTags [][]tag.Tag
   244  		for _, row := range rows {
   245  			gotTags = append(gotTags, row.Tags)
   246  		}
   247  		t.Fatalf("Failed to find row with keys %v among:\n%v", tags, gotTags)
   248  		return nil
   249  	}
   250  	return foundRow.Data.(*view.DistributionData)
   251  }
   252
View as plain text