github.com/newrelic/go-agent@v3.26.0+incompatible/_integrations/nrgrpc/example/server/server.go (about)

     1  // Copyright 2020 New Relic Corporation. All rights reserved.
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package main
     5  
     6  import (
     7  	"context"
     8  	fmt "fmt"
     9  	"io"
    10  	"net"
    11  	"os"
    12  
    13  	newrelic "github.com/newrelic/go-agent"
    14  	"github.com/newrelic/go-agent/_integrations/nrgrpc"
    15  	sampleapp "github.com/newrelic/go-agent/_integrations/nrgrpc/example/sampleapp"
    16  	"google.golang.org/grpc"
    17  )
    18  
    19  // Server is a gRPC server.
    20  type Server struct{}
    21  
    22  // processMessage processes each incoming Message.
    23  func processMessage(ctx context.Context, msg *sampleapp.Message) {
    24  	defer newrelic.StartSegment(newrelic.FromContext(ctx), "processMessage").End()
    25  	fmt.Printf("Message received: %s\n", msg.Text)
    26  }
    27  
    28  // DoUnaryUnary is a unary request, unary response method.
    29  func (s *Server) DoUnaryUnary(ctx context.Context, msg *sampleapp.Message) (*sampleapp.Message, error) {
    30  	processMessage(ctx, msg)
    31  	return &sampleapp.Message{Text: "Hello from DoUnaryUnary"}, nil
    32  }
    33  
    34  // DoUnaryStream is a unary request, stream response method.
    35  func (s *Server) DoUnaryStream(msg *sampleapp.Message, stream sampleapp.SampleApplication_DoUnaryStreamServer) error {
    36  	processMessage(stream.Context(), msg)
    37  	for i := 0; i < 3; i++ {
    38  		if err := stream.Send(&sampleapp.Message{Text: "Hello from DoUnaryStream"}); nil != err {
    39  			return err
    40  		}
    41  	}
    42  	return nil
    43  }
    44  
    45  // DoStreamUnary is a stream request, unary response method.
    46  func (s *Server) DoStreamUnary(stream sampleapp.SampleApplication_DoStreamUnaryServer) error {
    47  	for {
    48  		msg, err := stream.Recv()
    49  		if err == io.EOF {
    50  			return stream.SendAndClose(&sampleapp.Message{Text: "Hello from DoStreamUnary"})
    51  		} else if nil != err {
    52  			return err
    53  		}
    54  		processMessage(stream.Context(), msg)
    55  	}
    56  }
    57  
    58  // DoStreamStream is a stream request, stream response method.
    59  func (s *Server) DoStreamStream(stream sampleapp.SampleApplication_DoStreamStreamServer) error {
    60  	for {
    61  		msg, err := stream.Recv()
    62  		if err == io.EOF {
    63  			return nil
    64  		} else if nil != err {
    65  			return err
    66  		}
    67  		processMessage(stream.Context(), msg)
    68  		if err := stream.Send(&sampleapp.Message{Text: "Hello from DoStreamStream"}); nil != err {
    69  			return err
    70  		}
    71  	}
    72  }
    73  
    74  func mustGetEnv(key string) string {
    75  	if val := os.Getenv(key); "" != val {
    76  		return val
    77  	}
    78  	panic(fmt.Sprintf("environment variable %s unset", key))
    79  }
    80  
    81  func main() {
    82  	cfg := newrelic.NewConfig("gRPC Server", mustGetEnv("NEW_RELIC_LICENSE_KEY"))
    83  	cfg.Logger = newrelic.NewDebugLogger(os.Stdout)
    84  	app, err := newrelic.NewApplication(cfg)
    85  	if nil != err {
    86  		panic(err)
    87  	}
    88  
    89  	lis, err := net.Listen("tcp", "localhost:8080")
    90  	if err != nil {
    91  		panic(err)
    92  	}
    93  	grpcServer := grpc.NewServer(
    94  		// Add the New Relic gRPC server instrumentation
    95  		grpc.UnaryInterceptor(nrgrpc.UnaryServerInterceptor(app)),
    96  		grpc.StreamInterceptor(nrgrpc.StreamServerInterceptor(app)),
    97  	)
    98  	sampleapp.RegisterSampleApplicationServer(grpcServer, &Server{})
    99  	grpcServer.Serve(lis)
   100  }