Address PR #139 review: Node-native gRPC lifecycle safety

- GRPCChannelManager: closed flag and stale connectivity callback guards
- GRPCChannelManager: reportError notifies DISCONNECT on network errors
- ServiceManagementClient: track status, clear client on disconnect, RPC deadlines
- TraceSegmentServiceClient: single report timer/in-flight promise, flush safety
- MeterSender: status gating and shared in-flight report promise
- Remove unused GRPCStreamServiceStatus busy-wait class

Author: songzhendong

src/agent/core/meter/MeterSender.ts

@@ -34,10 +34,12 @@ const logReportError = throttled(logger, 'error', 30000);
 
 /** Reports Node.js runtime metrics via gRPC MeterReportService (Go/Python-compatible pipeline). */
 exportdefaultclassMeterSenderimplementsBootService,GRPCChannelListener{
-privatereporterClient!: MeterReportServiceClient;
+privatestatus=GRPCChannelStatus.DISCONNECT;
+privatereporterClient?: MeterReportServiceClient;
 privatereadonlybuffer: RuntimeSnapshot[]=[];
 privatecollectTimer?: NodeJS.Timeout;
 privatereportTimer?: NodeJS.Timeout;
+privatereporting?: Promise<void>;
 
 privatecollector!: RuntimeMetricsCollector;
 
@@ -57,9 +59,8 @@ export default class MeterSender implements BootService, GRPCChannelListener {
 }
 
 statusChanged(status: GRPCChannelStatus): void{
-if(status===GRPCChannelStatus.CONNECTED){
-this.reporterClient=this.createReporterClient();
-}
+this.status=status;
+this.reporterClient=status===GRPCChannelStatus.CONNECTED ? this.createReporterClient() : undefined;
 }
 
 privatecreateReporterClient(): MeterReportServiceClient{
@@ -70,20 +71,15 @@ export default class MeterSender implements BootService, GRPCChannelListener {
 );
 }
 
-getisConnected(): boolean{
-returnServiceManager.INSTANCE.findService(GRPCChannelManager)!.isConnected();
-}
-
 privatestartTimers(): void{
 this.collectTimer=setInterval(
 ()=>this.collectSample(),
 config.runtimeMetricsCollectPeriod||1000,
 )asNodeJS.Timeout;
 this.collectTimer.unref();
-this.reportTimer=setInterval(
-()=>this.reportBufferedMetrics(),
-config.runtimeMetricsReportPeriod||1000,
-)asNodeJS.Timeout;
+this.reportTimer=setInterval(()=>{
+voidthis.reportBufferedMetrics();
+},config.runtimeMetricsReportPeriod||1000)asNodeJS.Timeout;
 this.reportTimer.unref();
 }
 
@@ -95,56 +91,68 @@ export default class MeterSender implements BootService, GRPCChannelListener {
 this.buffer.push(this.collector.sample());
 }
 
-privatereportBufferedMetrics(callback?: ()=>void): void{
-try{
-if(this.buffer.length===0||!this.isConnected||!this.reporterClient){
-if(callback)callback();
-return;
-}
+privatereportBufferedMetrics(): Promise<void>{
+if(this.reporting){
+returnthis.reporting;
+}
 
-constsnapshots=this.buffer.splice(0,this.buffer.length);
-conststream=this.reporterClient.collect(
-newgrpc.Metadata(),
-{deadline: Date.now()+(config.traceTimeout||10000)},
-(error: grpc.ServiceError|null)=>{
-if(error){
-logReportError('Failed to report runtime meter data',error);
-ServiceManager.INSTANCE.findService(GRPCChannelManager)!.reportError(error);
-}
-if(callback)callback();
-},
-);
+this.reporting=this.doReportBufferedMetrics().finally(()=>{
+this.reporting=undefined;
+});
+
+returnthis.reporting;
+}
 
+privatedoReportBufferedMetrics(): Promise<void>{
+returnnewPromise((resolve)=>{
 try{
-letmetadataWritten=false;
-consttimestamp=Date.now();
-for(constsnapshotofsnapshots){
-for(constmeterDataofthis.collector.toMeterData(snapshot)){
-if(!metadataWritten){
-meterData
-.setService(config.serviceName!)
-.setServiceinstance(config.serviceInstance!)
-.setTimestamp(timestamp);
-metadataWritten=true;
+if(this.buffer.length===0||this.status!==GRPCChannelStatus.CONNECTED||!this.reporterClient){
+resolve();
+return;
+}
+
+constsnapshots=this.buffer.splice(0,this.buffer.length);
+conststream=this.reporterClient.collect(
+newgrpc.Metadata(),
+{deadline: Date.now()+(config.traceTimeout||10000)},
+(error: grpc.ServiceError|null)=>{
+if(error){
+logReportError('Failed to report runtime meter data',error);
+ServiceManager.INSTANCE.findService(GRPCChannelManager)!.reportError(error);
+}
+resolve();
+},
+);
+
+try{
+letmetadataWritten=false;
+consttimestamp=Date.now();
+for(constsnapshotofsnapshots){
+for(constmeterDataofthis.collector.toMeterData(snapshot)){
+if(!metadataWritten){
+meterData
+.setService(config.serviceName!)
+.setServiceinstance(config.serviceInstance!)
+.setTimestamp(timestamp);
+metadataWritten=true;
+}
+stream.write(meterData);
 }
-stream.write(meterData);
 }
+}finally{
+stream.end();
 }
-}finally{
-stream.end();
+}catch(error){
+logReportError('Failed to report runtime meter data',error);
+ServiceManager.INSTANCE.findService(GRPCChannelManager)!.reportError(error);
+resolve();
 }
-}catch(error){
-logReportError('Failed to report runtime meter data',error);
-ServiceManager.INSTANCE.findService(GRPCChannelManager)!.reportError(error);
-if(callback)callback();
-}
+});
 }
 
 flush(): Promise<any>|null{
-returnnewPromise((resolve)=>{
-this.collectSample();
-this.reportBufferedMetrics(resolve);
-});
+this.collectSample();
+returnthis.reportBufferedMetrics();
 }
 
 shutdown(): void{
@@ -156,6 +164,8 @@ export default class MeterSender implements BootService, GRPCChannelListener {
 clearInterval(this.reportTimer);
 this.reportTimer=undefined;
 }
+this.reporting=undefined;
+this.reporterClient=undefined;
 this.buffer.length=0;
 this.collector.destroy();
 logger.info('MeterSender destroyed and resources cleaned up');

src/agent/core/remote/GRPCChannelManager.ts

@@ -32,6 +32,18 @@ import TLSChannelBuilder from './TLSChannelBuilder';
 
 constlogger=createLogger(__filename);
 
+functionisGrpcNetworkError(error: unknown): boolean{
+constcode=(errorasgrpc.ServiceError|undefined)?.code;
+
+return(
+code===grpc.status.UNAVAILABLE||
+code===grpc.status.PERMISSION_DENIED||
+code===grpc.status.UNAUTHENTICATED||
+code===grpc.status.RESOURCE_EXHAUSTED||
+code===grpc.status.UNKNOWN
+);
+}
+
 /**
  * Shared gRPC channel manager (Java GRPCChannelManager skeleton).
  * V1: single address; V2 reserved: multi-address failover via reportError().
@@ -40,6 +52,7 @@ export default class GRPCChannelManager implements BootService {
 privatemanagedChannel: GRPCChannel|null=null;
 privatereadonlylisteners: GRPCChannelListener[]=[];
 privatelastStatus: GRPCChannelStatus|null=null;
+privateclosed=false;
 
 /** V1: first address when comma-separated; V2: failover selection. */
 resolveAddress(): string{
@@ -74,14 +87,21 @@ export default class GRPCChannelManager implements BootService {
 returnNumber.MAX_SAFE_INTEGER;
 }
 
-/** V2 hook: network errors may trigger address failover. */
+/** Notify DISCONNECT on network errors so periodic work stops until grpc-js reconnects. */
 reportError(error: unknown): void{
-logger.debug('gRPC report error (multi-address failover reserved for V2): %s',error);
+if(!isGrpcNetworkError(error)){
+logger.debug('gRPC report error (ignored): %s',error);
+return;
+}
+
+logger.debug('gRPC network error, notify DISCONNECT: %s',error);
+this.notify(GRPCChannelStatus.DISCONNECT);
 }
 
 prepare(): void{}
 
 boot(): void{
+this.closed=false;
 constaddress=this.resolveAddress();
 const[host,portText]=address.split(':');
 constport=Number.parseInt(portText,10);
@@ -103,16 +123,29 @@ export default class GRPCChannelManager implements BootService {
 onComplete(): void{}
 
 shutdown(): void{
-this.managedChannel?.shutdownNow();
+this.closed=true;
+constmanaged=this.managedChannel;
 this.managedChannel=null;
+managed?.shutdownNow();
+this.notify(GRPCChannelStatus.DISCONNECT);
 }
 
 privatewatchConnectivityState(): void{
-constchannel=this.getChannel();
+constmanaged=this.managedChannel;
+if(this.closed||!managed){
+return;
+}
+
+constchannel=managed.getChannel();
 constcurrentState=channel.getConnectivityState(true);
+
 channel.watchConnectivityState(currentState,Infinity,(error)=>{
+if(this.closed||this.managedChannel!==managed){
+return;
+}
+
 if(error){
-logger.debug('Channel connectivity watch error: %s',error.message);
+logger.debug('Channel connectivity watch stopped: %s',error.message);
 return;
 }