@@ -3,6 +3,7 @@ package gofr
33import (
44 "context"
55 "errors"
6+ "fmt"
67 "net"
78 "reflect"
89 "strconv"
@@ -27,6 +28,12 @@ type grpcServer struct {
2728 config config.Config
2829}
2930
31+ var (
32+ ErrNonAddressable = errors .New ("cannot inject container as it is not addressable or is nil" )
33+ ErrInvalidPort = errors .New ("invalid port number" )
34+ ErrFailedCreateServer = errors .New ("failed to create gRPC server" )
35+ )
36+
3037// AddGRPCServerOptions allows users to add custom gRPC server options such as TLS configuration,
3138// timeouts, interceptors, and other server-specific settings in a single call.
3239//
@@ -42,6 +49,12 @@ type grpcServer struct {
4249// This function accepts a variadic list of gRPC server options (grpc.ServerOption) and appends them
4350// to the server's configuration. It allows fine-tuning of the gRPC server's behavior during its initialization.
4451func (a * App ) AddGRPCServerOptions (grpcOpts ... grpc.ServerOption ) {
52+ if len (grpcOpts ) == 0 {
53+ a .container .Logger .Debug ("no gRPC server options provided" )
54+ return
55+ }
56+
57+ a .container .Logger .Debugf ("adding %d gRPC server options" , len (grpcOpts ))
4558 a .grpcServer .options = append (a .grpcServer .options , grpcOpts ... )
4659}
4760
@@ -55,14 +68,32 @@ func (a *App) AddGRPCServerOptions(grpcOpts ...grpc.ServerOption) {
5568// }
5669// app.AddGRPCUnaryInterceptors(loggingInterceptor)
5770func (a * App ) AddGRPCUnaryInterceptors (interceptors ... grpc.UnaryServerInterceptor ) {
71+ if len (interceptors ) == 0 {
72+ a .container .Logger .Debug ("no unary interceptors provided" )
73+ return
74+ }
75+
76+ a .container .Logger .Debugf ("adding %d valid unary interceptors" , len (interceptors ))
5877 a .grpcServer .interceptors = append (a .grpcServer .interceptors , interceptors ... )
5978}
6079
6180func (a * App ) AddGRPCServerStreamInterceptors (interceptors ... grpc.StreamServerInterceptor ) {
81+ if len (interceptors ) == 0 {
82+ a .container .Logger .Debug ("no stream interceptors provided" )
83+ return
84+ }
85+
86+ a .container .Logger .Debugf ("adding %d stream interceptors" , len (interceptors ))
6287 a .grpcServer .streamInterceptors = append (a .grpcServer .streamInterceptors , interceptors ... )
6388}
6489
65- func newGRPCServer (c * container.Container , port int , cfg config.Config ) * grpcServer {
90+ func newGRPCServer (c * container.Container , port int , cfg config.Config ) (* grpcServer , error ) {
91+ if port <= 0 || port > 65535 {
92+ return nil , fmt .Errorf ("%w: %d" , ErrInvalidPort , port )
93+ }
94+
95+ registerGRPCMetrics (c )
96+
6697 middleware := make ([]grpc.UnaryServerInterceptor , 0 )
6798 middleware = append (middleware ,
6899 grpc_recovery .UnaryServerInterceptor (),
@@ -78,41 +109,78 @@ func newGRPCServer(c *container.Container, port int, cfg config.Config) *grpcSer
78109 interceptors : middleware ,
79110 streamInterceptors : streamMiddleware ,
80111 config : cfg ,
81- }
112+ }, nil
82113}
83114
84- func (g * grpcServer ) createServer () {
115+ // registerGRPCMetrics registers essential gRPC metrics.
116+ func registerGRPCMetrics (c * container.Container ) {
117+ c .Metrics ().NewGauge ("grpc_server_status" , "gRPC server status (1=running, 0=stopped)" )
118+ c .Metrics ().NewCounter ("grpc_server_errors_total" , "Total gRPC server errors" )
119+ c .Metrics ().NewCounter ("grpc_services_registered_total" , "Total gRPC services registered" )
120+ }
121+
122+ func (g * grpcServer ) createServer () error {
85123 interceptorOption := grpc .UnaryInterceptor (grpc_middleware .ChainUnaryServer (g .interceptors ... ))
86124 streamOpt := grpc .StreamInterceptor (grpc_middleware .ChainStreamServer (g .streamInterceptors ... ))
87125 g .options = append (g .options , interceptorOption , streamOpt )
88126
89127 g .server = grpc .NewServer (g .options ... )
128+ if g .server == nil {
129+ return ErrFailedCreateServer
130+ }
90131
91132 enabled := strings .ToLower (g .config .GetOrDefault ("GRPC_ENABLE_REFLECTION" , "false" ))
92- if enabled != defaultReflection {
133+ if enabled == defaultTelemetry {
93134 reflection .Register (g .server )
94135 }
136+
137+ return nil
95138}
96139
97140func (g * grpcServer ) Run (c * container.Container ) {
98141 if g .server == nil {
99- g .createServer ()
142+ if err := g .createServer (); err != nil {
143+ c .Logger .Fatalf ("failed to create gRPC server: %v" , err )
144+ c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
145+
146+ return
147+ }
148+ }
149+
150+ if ! isPortAvailable (g .port ) {
151+ c .Logger .Fatalf ("gRPC port %d is blocked or unreachable" , g .port )
152+ c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
153+ c .Metrics ().SetGauge ("grpc_server_status" , 0 )
154+
155+ return
100156 }
101157
102158 addr := ":" + strconv .Itoa (g .port )
103159
104160 c .Logger .Infof ("starting gRPC server at %s" , addr )
105161
106- listener , err := net .Listen ("tcp" , addr )
162+ listener , err := ( & net.ListenConfig {}). Listen (context . Background (), "tcp" , addr )
107163 if err != nil {
108164 c .Logger .Errorf ("error in starting gRPC server at %s: %s" , addr , err )
165+ c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
166+ c .Metrics ().SetGauge ("grpc_server_status" , 0 )
167+
109168 return
110169 }
111170
171+ c .Metrics ().SetGauge ("grpc_server_status" , 1 )
172+ c .Logger .Infof ("gRPC server started successfully on %s" , addr )
173+
112174 if err := g .server .Serve (listener ); err != nil {
113175 c .Logger .Errorf ("error in starting gRPC server at %s: %s" , addr , err )
176+ c .Metrics ().IncrementCounter (context .Background (), "grpc_server_errors_total" )
177+ c .Metrics ().SetGauge ("grpc_server_status" , 0 )
178+
114179 return
115180 }
181+
182+ c .Logger .Infof ("gRPC server stopped on %s" , addr )
183+ c .Metrics ().SetGauge ("grpc_server_status" , 0 )
116184}
117185
118186func (g * grpcServer ) Shutdown (ctx context.Context ) error {
@@ -129,29 +197,27 @@ func (g *grpcServer) Shutdown(ctx context.Context) error {
129197 })
130198}
131199
132- var (
133- errNonAddressable = errors .New ("cannot inject container as it is not addressable or is fail" )
134- )
135-
136200// RegisterService adds a gRPC service to the GoFr application.
137201func (a * App ) RegisterService (desc * grpc.ServiceDesc , impl any ) {
138- if ! a .grpcRegistered && ! isPortAvailable (a .grpcServer .port ) {
139- a .container .Logger .Fatalf ("gRPC port %d is blocked or unreachable" , a .grpcServer .port )
140- }
141-
142202 if ! a .grpcRegistered {
143- a .grpcServer .createServer ()
203+ if err := a .grpcServer .createServer (); err != nil {
204+ a .container .Logger .Errorf ("failed to create gRPC server for service %s: %v" , desc .ServiceName , err )
205+ return
206+ }
144207 }
145208
146- a .container .Logger .Infof ("registering gRPC Server : %s" , desc .ServiceName )
209+ a .container .Logger .Infof ("registering gRPC Service : %s" , desc .ServiceName )
147210 a .grpcServer .server .RegisterService (desc , impl )
148211
212+ a .container .Metrics ().IncrementCounter (context .Background (), "grpc_services_registered_total" )
213+
149214 err := injectContainer (impl , a .container )
150215 if err != nil {
151- return
216+ a . container . Logger . Fatalf ( "failed to inject container into gRPC service %s: %v" , desc . ServiceName , err )
152217 }
153218
154219 a .grpcRegistered = true
220+ a .container .Logger .Infof ("successfully registered gRPC service: %s" , desc .ServiceName )
155221}
156222
157223func injectContainer (impl any , c * container.Container ) error {
@@ -177,8 +243,8 @@ func injectContainer(impl any, c *container.Container) error {
177243
178244 if f .Type == reflect .TypeOf (c ) {
179245 if ! v .CanSet () {
180- c .Logger .Error (errNonAddressable )
181- return errNonAddressable
246+ c .Logger .Error (ErrNonAddressable )
247+ return ErrNonAddressable
182248 }
183249
184250 v .Set (reflect .ValueOf (c ))
@@ -189,8 +255,8 @@ func injectContainer(impl any, c *container.Container) error {
189255
190256 if f .Type == reflect .TypeOf (* c ) {
191257 if ! v .CanSet () {
192- c .Logger .Error (errNonAddressable )
193- return errNonAddressable
258+ c .Logger .Error (ErrNonAddressable )
259+ return ErrNonAddressable
194260 }
195261
196262 v .Set (reflect .ValueOf (* c ))
@@ -202,3 +268,11 @@ func injectContainer(impl any, c *container.Container) error {
202268
203269 return nil
204270}
271+
272+ func (g * grpcServer ) addServerOptions (opts ... grpc.ServerOption ) {
273+ g .options = append (g .options , opts ... )
274+ }
275+
276+ func (g * grpcServer ) addUnaryInterceptors (interceptors ... grpc.UnaryServerInterceptor ) {
277+ g .interceptors = append (g .interceptors , interceptors ... )
278+ }
0 commit comments