Add web page summary (#45)

Add web page summary

Author: the-ericwang35

cmd/mock_server.go

@@ -16,6 +16,7 @@ package main
 
 import (
 	"flag"
+	"html/template"
 	"log"
 	"net"
 	"os"
@@ -26,7 +27,6 @@ import (
 
 	"github.com/googleinterns/cloud-operations-api-mock/server/metric"
 	"github.com/googleinterns/cloud-operations-api-mock/server/trace"
-
 	"google.golang.org/genproto/googleapis/devtools/cloudtrace/v2"
 	"google.golang.org/genproto/googleapis/monitoring/v3"
 	"google.golang.org/grpc"
@@ -38,14 +38,21 @@ const (
 
 var (
 	address = flag.String("address", defaultAddress,
-		"The address to run the server on, of the form <host>:<port>.")
+		"The address to run the server on, of the form <host>:<port>")
+	summary = flag.Bool("summary", false,
+		"If flag is set, a summary page HTML file will be generated")
 )
 
 func main() {
 	flag.Parse()
 	startStandaloneServer()
 }
 
+// startStandaloneServer spins up the mock server, and listens for requests.
+// Upon detecting a kill signal, it will shutdown and optionally print out a table of results.
+// Flags:
+// -address=<host:port> will start the server at the given address
+// -summary will tell the server to generate an HTML file containing the data received.
 func startStandaloneServer() {
 	lis, err := net.Listen("tcp", *address)
 	if err != nil {
@@ -62,12 +69,34 @@ func startStandaloneServer() {
 
 	sig := make(chan os.Signal)
 	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
+
+	// Allow the summary to be fully written before exiting.
+	finish := make(chan bool)
+
 	go func() {
 		<-sig
 		grpcServer.GracefulStop()
+		if *summary {
+			writeSummaryPage(mockTraceServer.ResultTable())
+		}
+		finish <- true
 	}()
 
 	if err := grpcServer.Serve(lis); err != nil {
 		log.Fatalf("mock server failed to serve: %v", err)
 	}
+	<-finish
+}
+
+// writeSummaryPage creates summary.html from the results and the template HTML.
+func writeSummaryPage(results []*cloudtrace.Span) {
+	outputFile, err := os.Create("summary.html")
+	if err != nil {
+		panic(err)
+	}
+	t := template.Must(template.ParseFiles("../static/summary_template.html"))
+	err = t.Execute(outputFile, results)
+	if err != nil {
+		panic(err)
+	}
 }

go.mod

@@ -10,4 +10,4 @@ require (
 	google.golang.org/genproto v0.0.0-20200605102947-12044bf5ea91
 	google.golang.org/grpc v1.29.1
 	google.golang.org/protobuf v1.24.0
-)
+)

internal/validation/mock_trace_validation.go

@@ -16,15 +16,16 @@ package validation
 
 import (
 	"context"
-	"fmt"
 	"reflect"
 	"regexp"
+	"sync"
 	"time"
 
 	"github.com/golang/protobuf/ptypes"
-
 	"google.golang.org/genproto/googleapis/devtools/cloudtrace/v2"
-	"google.golang.org/genproto/googleapis/rpc/errdetails"
+	genprotoStatus "google.golang.org/genproto/googleapis/rpc/status"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 const (
@@ -56,57 +57,98 @@ var (
 	agentRegex     = regexp.MustCompile(`^opentelemetry-[a-zA-Z]+ [0-9]+\.[0-9]+\.[0-9]+; google-cloud-trace-exporter [0-9]+\.[0-9]+\.[0-9]+$`)
 )
 
+// SpanData wraps all the span data on the server into a struct.
+type SpanData struct {
+	// If a batch has a bad span, we don't write batch to memory, but still want
+	// info on them for summary, so need SpansSummary
+	SpansSummary      []*cloudtrace.Span
+	UploadedSpanNames map[string]struct{}
+	UploadedSpans     []*cloudtrace.Span
+	Mutex             sync.RWMutex
+}
+
 // ValidateSpans checks that the spans conform to the API requirements.
 // That is, required fields are present, and optional fields are of the correct form.
-func ValidateSpans(requestName string, spans ...*cloudtrace.Span) error {
+// If any violations are detected, the errors will be added to the result table.
+func ValidateSpans(requestName string, spanData *SpanData, spans ...*cloudtrace.Span) error {
+	var overallError error
+	currentRequestSpanNames := make(map[string]struct{})
+
 	for _, span := range spans {
+		var currentError error
+
 		// Validate required fields are present and semantically make sense.
 		if err := CheckForRequiredFields(requiredFields, reflect.ValueOf(span), requestName); err != nil {
-			return err
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
-		if err := validateName(span.Name); err != nil {
-			return err
+		if err := validateName(span.Name, spanData.UploadedSpanNames, currentRequestSpanNames); err != nil {
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
 		if err := validateTimeStamps(span); err != nil {
-			return err
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
 		if err := validateDisplayName(span.DisplayName); err != nil {
-			return err
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
 
 		// Validate that if optional fields are present, they conform to the API.
 		if err := validateAttributes(span.Attributes, maxAttributes); err != nil {
-			return err
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
 		if err := validateTimeEvents(span.TimeEvents); err != nil {
-			return err
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
 		if err := validateLinks(span.Links); err != nil {
-			return err
+			addSpanToSummary(&spanData.SpansSummary, span, err)
+			currentError = err
 		}
+
+		if currentError == nil {
+			addSpanToSummary(&spanData.SpansSummary, span, nil)
+		} else {
+			overallError = currentError
+		}
+	}
+
+	if overallError != nil {
+		return overallError
 	}
+
 	return nil
 }
 
-// AddSpans adds the given spans to the list of uploaded spans as long as there are no duplicate names.
-// If a duplicate span name is detected, it will not be written, and an error is returned.
-func AddSpans(uploadedSpans *[]*cloudtrace.Span, uploadedSpanNames map[string]struct{}, spans ...*cloudtrace.Span) error {
-	br := &errdetails.ErrorInfo{}
+// addSpanToSummary sets the span's status and adds it to the summary slice.
+func addSpanToSummary(spanSummary *[]*cloudtrace.Span, span *cloudtrace.Span, err error) {
+	setSpanStatus(span, err)
+	*spanSummary = append(*spanSummary, span)
+}
 
-	for _, span := range spans {
-		if _, ok := uploadedSpanNames[span.Name]; ok {
-			br.Reason = span.Name
-			st, err := statusDuplicateSpanName.WithDetails(br)
-			if err != nil {
-				panic(fmt.Sprintf("unexpected error attaching metadata: %v", err))
-			}
-			return st.Err()
+func setSpanStatus(span *cloudtrace.Span, err error) {
+	if err == nil {
+		span.Status = &genprotoStatus.Status{
+			Code:    int32(codes.OK),
+			Message: "OK",
+		}
+	} else {
+		span.Status = &genprotoStatus.Status{
+			Code:    int32(status.Convert(err).Code()),
+			Message: status.Convert(err).Message(),
 		}
-		*uploadedSpans = append(*uploadedSpans, span)
-		uploadedSpanNames[span.Name] = struct{}{}
 	}
+}
 
-	return nil
+// AddSpans adds the given spans to the list of uploaded spans.
+func AddSpans(spanData *SpanData, spans ...*cloudtrace.Span) {
+	for _, span := range spans {
+		spanData.UploadedSpans = append(spanData.UploadedSpans, span)
+		spanData.UploadedSpanNames[span.Name] = struct{}{}
+	}
 }
 
 // Delay will block for the specified amount of time.
@@ -137,13 +179,23 @@ func validateDisplayName(displayName *cloudtrace.TruncatableString) error {
 	return nil
 }
 
-// validateName verifies that the span is of the form:
+// validateName verifies that the span name is not a duplicate, and is of the form:
 // projects/{project_id}/traces/{trace_id}/spans/{span_id}
 // where trace_id is a 32-char hex encoding, and span_id is a 16-char hex encoding.
-func validateName(name string) error {
+func validateName(name string, spanNames map[string]struct{}, currentRequestSpanNames map[string]struct{}) error {
+	if _, ok := spanNames[name]; ok {
+		return statusDuplicateSpanName
+	}
+
+	if _, ok := currentRequestSpanNames[name]; ok {
+		return statusDuplicateSpanName
+	}
+
 	if !spanNameRegex.MatchString(name) {
 		return statusInvalidSpanName
 	}
+
+	currentRequestSpanNames[name] = struct{}{}
 	return nil
 }
 

internal/validation/statuses.go

@@ -56,7 +56,7 @@ var (
 		fmt.Sprintf("annotation descriptions have a max length of %v bytes", maxAnnotationBytes))
 	statusTooManyLinks = status.Error(codes.InvalidArgument,
 		fmt.Sprintf("a span can have at most %v links", maxLinks))
-	statusDuplicateSpanName = status.New(codes.AlreadyExists, "duplicate span name")
+	statusDuplicateSpanName = status.Error(codes.AlreadyExists, "duplicate span name")
 
 	// Metric statuses.
 	statusDuplicateMetricDescriptorType = status.New(codes.AlreadyExists, "metric descriptor of same type already exists")

server/trace/mock_trace.go

@@ -30,46 +30,54 @@ import (
 type MockTraceServer struct {
 	cloudtrace.UnimplementedTraceServiceServer
 	mocktrace.UnimplementedMockTraceServiceServer
-	uploadedSpanNames map[string]struct{}
-	uploadedSpans     []*cloudtrace.Span
-	uploadedSpansLock sync.Mutex
-	delay             time.Duration
-	delayLock         sync.Mutex
-	onUpload          func(ctx context.Context, spans []*cloudtrace.Span)
-	onUploadLock      sync.Mutex
+	spanData     *validation.SpanData
+	delay        time.Duration
+	delayLock    sync.Mutex
+	onUpload     func(ctx context.Context, spans []*cloudtrace.Span)
+	onUploadLock sync.Mutex
 }
 
 // NewMockTraceServer creates a new MockTraceServer and returns a pointer to it.
 func NewMockTraceServer() *MockTraceServer {
 	uploadedSpanNames := make(map[string]struct{})
-	return &MockTraceServer{uploadedSpanNames: uploadedSpanNames}
+	spanData := &validation.SpanData{
+		UploadedSpanNames: uploadedSpanNames,
+	}
+	return &MockTraceServer{spanData: spanData}
 }
 
 // BatchWriteSpans creates and stores a list of spans on the server.
+// If ANY of the spans in the request are invalid, ALL spans will be dropped.
 func (s *MockTraceServer) BatchWriteSpans(ctx context.Context, req *cloudtrace.BatchWriteSpansRequest) (*empty.Empty, error) {
 	if err := validation.ValidateProjectName(req.Name); err != nil {
 		return nil, err
 	}
-	if err := validation.ValidateSpans("BatchWriteSpans", req.Spans...); err != nil {
+
+	if err := validation.Delay(ctx, s.delay); err != nil {
 		return nil, err
 	}
+
 	if s.onUpload != nil {
 		s.onUpload(ctx, req.Spans)
 	}
-	if err := validation.Delay(ctx, s.delay); err != nil {
-		return nil, err
-	}
-	s.uploadedSpansLock.Lock()
-	defer s.uploadedSpansLock.Unlock()
-	if err := validation.AddSpans(&s.uploadedSpans, s.uploadedSpanNames, req.Spans...); err != nil {
+
+	s.spanData.Mutex.Lock()
+	defer s.spanData.Mutex.Unlock()
+	if err := validation.ValidateSpans("BatchWriteSpans", s.spanData, req.Spans...); err != nil {
 		return nil, err
 	}
+
+	validation.AddSpans(s.spanData, req.Spans...)
+
 	return &empty.Empty{}, nil
 }
 
-// CreateSpan creates and stores a single span on the server.
+// CreateSpan validates a single span, and returns the Span proto.
 func (s *MockTraceServer) CreateSpan(ctx context.Context, span *cloudtrace.Span) (*cloudtrace.Span, error) {
-	if err := validation.ValidateSpans("CreateSpan", span); err != nil {
+	// Validate the span and add to result table.
+	s.spanData.Mutex.Lock()
+	defer s.spanData.Mutex.Unlock()
+	if err := validation.ValidateSpans("CreateSpan", s.spanData, span); err != nil {
 		return nil, err
 	}
 	return span, nil
@@ -78,26 +86,26 @@ func (s *MockTraceServer) CreateSpan(ctx context.Context, span *cloudtrace.Span)
 // GetNumSpans returns the number of spans currently stored on the server.
 // Used by the library implementation to avoid having to make a network call.
 func (s *MockTraceServer) GetNumSpans() int {
-	s.uploadedSpansLock.Lock()
-	defer s.uploadedSpansLock.Unlock()
-	return len(s.uploadedSpans)
+	s.spanData.Mutex.RLock()
+	defer s.spanData.Mutex.RUnlock()
+	return len(s.spanData.UploadedSpans)
 }
 
 // ListSpans returns a list of all the spans currently stored on the server.
 func (s *MockTraceServer) ListSpans(ctx context.Context, req *empty.Empty) (*mocktrace.ListSpansResponse, error) {
-	s.uploadedSpansLock.Lock()
-	defer s.uploadedSpansLock.Unlock()
+	s.spanData.Mutex.RLock()
+	defer s.spanData.Mutex.RUnlock()
 	return &mocktrace.ListSpansResponse{
-		Spans: s.uploadedSpans,
+		Spans: s.spanData.UploadedSpans,
 	}, nil
 }
 
 // GetSpan returns the span that was stored in memory at the given index.
 // If the index is out of bounds, nil is returned.
 func (s *MockTraceServer) GetSpan(index int) *cloudtrace.Span {
-	s.uploadedSpansLock.Lock()
-	defer s.uploadedSpansLock.Unlock()
-	span := validation.AccessSpan(index, s.uploadedSpans)
+	s.spanData.Mutex.RLock()
+	defer s.spanData.Mutex.RUnlock()
+	span := validation.AccessSpan(index, s.spanData.UploadedSpans)
 	return span
 }
 
@@ -114,3 +122,7 @@ func (s *MockTraceServer) SetOnUpload(onUpload func(ctx context.Context, spans [
 	defer s.onUploadLock.Unlock()
 	s.onUpload = onUpload
 }
+
+func (s *MockTraceServer) ResultTable() []*cloudtrace.Span {
+	return s.spanData.SpansSummary
+}