rocketmq-client-nodejs-bate 1.0.12

package/src/client/RpcClient.ts

@@ -0,0 +1,258 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ChannelCredentials, Metadata } from '@grpc/grpc-js';
+import { MessagingServiceClient } from '../../proto/apache/rocketmq/v2/service_grpc_pb';
+import {
+  AckMessageRequest,
+  AckMessageResponse,
+  ChangeInvisibleDurationRequest,
+  ChangeInvisibleDurationResponse,
+  EndTransactionRequest,
+  EndTransactionResponse,
+  ForwardMessageToDeadLetterQueueRequest,
+  ForwardMessageToDeadLetterQueueResponse,
+  GetOffsetRequest,
+  GetOffsetResponse,
+  HeartbeatRequest,
+  HeartbeatResponse,
+  NotifyClientTerminationRequest,
+  NotifyClientTerminationResponse,
+  PullMessageRequest,
+  PullMessageResponse,
+  QueryAssignmentRequest,
+  QueryAssignmentResponse,
+  QueryOffsetRequest,
+  QueryOffsetResponse,
+  QueryRouteRequest,
+  QueryRouteResponse,
+  RecallMessageRequest,
+  RecallMessageResponse,
+  ReceiveMessageRequest,
+  ReceiveMessageResponse,
+  SendMessageRequest,
+  SendMessageResponse,
+  UpdateOffsetRequest,
+  UpdateOffsetResponse,
+} from '../../proto/apache/rocketmq/v2/service_pb';
+import { Endpoints } from '../route';
+
+export class RpcClient {
+  #client: MessagingServiceClient;
+  #activityTime = Date.now();
+
+  constructor(endpoints: Endpoints, sslEnabled: boolean) {
+    const address = endpoints.getGrpcTarget();
+    const grpcCredentials = sslEnabled ? ChannelCredentials.createSsl() : ChannelCredentials.createInsecure();
+    this.#client = new MessagingServiceClient(address, grpcCredentials);
+  }
+
+  #getAndActivityRpcClient() {
+    this.#activityTime = Date.now();
+    return this.#client;
+  }
+
+  #getDeadline(duration: number) {
+    return Date.now() + duration;
+  }
+
+  idleDuration() {
+    return Date.now() - this.#activityTime;
+  }
+
+  close() {
+    this.#client.close();
+  }
+
+  /**
+   * Query topic route
+   *
+   * @param request query route request.
+   * @param metadata gRPC request header metadata.
+   * @param duration request max duration in milliseconds.
+   */
+  async queryRoute(request: QueryRouteRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<QueryRouteResponse>((resolve, reject) => {
+      client.queryRoute(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async heartbeat(request: HeartbeatRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<HeartbeatResponse>((resolve, reject) => {
+      client.heartbeat(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async sendMessage(request: SendMessageRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<SendMessageResponse>((resolve, reject) => {
+      client.sendMessage(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async queryAssignment(request: QueryAssignmentRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<QueryAssignmentResponse>((resolve, reject) => {
+      client.queryAssignment(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async receiveMessage(request: ReceiveMessageRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    const readable = client.receiveMessage(request, metadata, { deadline });
+    const responses: ReceiveMessageResponse[] = [];
+    for await (const res of readable) {
+      responses.push(res);
+    }
+    return responses;
+  }
+
+  async ackMessage(request: AckMessageRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<AckMessageResponse>((resolve, reject) => {
+      client.ackMessage(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async forwardMessageToDeadLetterQueue(request: ForwardMessageToDeadLetterQueueRequest,
+    metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<ForwardMessageToDeadLetterQueueResponse>((resolve, reject) => {
+      client.forwardMessageToDeadLetterQueue(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async pullMessage(request: PullMessageRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    const readable = client.pullMessage(request, metadata, { deadline });
+    const responses: PullMessageResponse[] = [];
+    for await (const res of readable) {
+      responses.push(res);
+    }
+    return responses;
+  }
+
+  async updateOffset(request: UpdateOffsetRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<UpdateOffsetResponse>((resolve, reject) => {
+      client.updateOffset(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async getOffset(request: GetOffsetRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<GetOffsetResponse>((resolve, reject) => {
+      client.getOffset(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async queryOffset(request: QueryOffsetRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<QueryOffsetResponse>((resolve, reject) => {
+      client.queryOffset(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async endTransaction(request: EndTransactionRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<EndTransactionResponse>((resolve, reject) => {
+      client.endTransaction(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  telemetry(metadata: Metadata) {
+    const client = this.#getAndActivityRpcClient();
+    return client.telemetry(metadata);
+  }
+
+  async notifyClientTermination(request: NotifyClientTerminationRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<NotifyClientTerminationResponse>((resolve, reject) => {
+      client.notifyClientTermination(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async changeInvisibleDuration(request: ChangeInvisibleDurationRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<ChangeInvisibleDurationResponse>((resolve, reject) => {
+      client.changeInvisibleDuration(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+
+  async recallMessage(request: RecallMessageRequest, metadata: Metadata, duration: number) {
+    const client = this.#getAndActivityRpcClient();
+    const deadline = this.#getDeadline(duration);
+    return new Promise<RecallMessageResponse>((resolve, reject) => {
+      client.recallMessage(request, metadata, { deadline }, (e, res) => {
+        if (e) return reject(e);
+        resolve(res);
+      });
+    });
+  }
+}

package/src/client/RpcClientManager.ts

@@ -0,0 +1,180 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Metadata } from '@grpc/grpc-js';
+import {
+  AckMessageRequest,
+  ChangeInvisibleDurationRequest,
+  EndTransactionRequest,
+  ForwardMessageToDeadLetterQueueRequest,
+  GetOffsetRequest,
+  HeartbeatRequest, NotifyClientTerminationRequest, PullMessageRequest,
+  QueryAssignmentRequest, QueryOffsetRequest, QueryRouteRequest,
+  ReceiveMessageRequest, SendMessageRequest, UpdateOffsetRequest,
+  RecallMessageRequest,
+} from '../../proto/apache/rocketmq/v2/service_pb';
+import { Endpoints } from '../route';
+import { ILogger } from './Logger';
+import { RpcClient } from './RpcClient';
+import type { BaseClient } from './BaseClient';
+
+const RPC_CLIENT_MAX_IDLE_DURATION = 30 * 60000; // 30 minutes
+const RPC_CLIENT_IDLE_CHECK_PERIOD = 60000;
+
+export class RpcClientManager {
+  #rpcClients = new Map<Endpoints, RpcClient>();
+  #baseClient: BaseClient;
+  #logger: ILogger;
+  #clearIdleRpcClientsTimer: NodeJS.Timeout;
+
+  constructor(baseClient: BaseClient, logger: ILogger) {
+    this.#baseClient = baseClient;
+    this.#logger = logger;
+    this.#startUp();
+  }
+
+  #startUp() {
+    this.#clearIdleRpcClientsTimer = setInterval(() => {
+      this.#clearIdleRpcClients();
+    }, RPC_CLIENT_IDLE_CHECK_PERIOD);
+  }
+
+  #clearIdleRpcClients() {
+    for (const [ endpoints, rpcClient ] of this.#rpcClients.entries()) {
+      const idleDuration = rpcClient.idleDuration();
+      if (idleDuration > RPC_CLIENT_MAX_IDLE_DURATION) {
+        rpcClient.close();
+        this.#rpcClients.delete(endpoints);
+        this.#logger.info('[RpcClientManager] Rpc client has been idle for a long time, endpoints=%s, idleDuration=%s, clientId=%s',
+          endpoints, idleDuration, RPC_CLIENT_MAX_IDLE_DURATION, this.#baseClient.clientId);
+      }
+    }
+  }
+
+  #getRpcClient(endpoints: Endpoints) {
+    let rpcClient = this.#rpcClients.get(endpoints);
+    if (!rpcClient) {
+      rpcClient = new RpcClient(endpoints, this.#baseClient.sslEnabled);
+      this.#rpcClients.set(endpoints, rpcClient);
+    }
+    return rpcClient;
+  }
+
+  close() {
+    for (const [ endpoints, rpcClient ] of this.#rpcClients.entries()) {
+      rpcClient.close();
+      this.#rpcClients.delete(endpoints);
+    }
+    clearInterval(this.#clearIdleRpcClientsTimer);
+  }
+
+  async queryRoute(endpoints: Endpoints, request: QueryRouteRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.queryRoute(request, metadata, duration);
+  }
+
+  async heartbeat(endpoints: Endpoints, request: HeartbeatRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.heartbeat(request, metadata, duration);
+  }
+
+  async sendMessage(endpoints: Endpoints, request: SendMessageRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.sendMessage(request, metadata, duration);
+  }
+
+  async queryAssignment(endpoints: Endpoints, request: QueryAssignmentRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.queryAssignment(request, metadata, duration);
+  }
+
+  async receiveMessage(endpoints: Endpoints, request: ReceiveMessageRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.receiveMessage(request, metadata, duration);
+  }
+
+  async ackMessage(endpoints: Endpoints, request: AckMessageRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.ackMessage(request, metadata, duration);
+  }
+
+  async forwardMessageToDeadLetterQueue(endpoints: Endpoints, request: ForwardMessageToDeadLetterQueueRequest,
+    duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.forwardMessageToDeadLetterQueue(request, metadata, duration);
+  }
+
+  async pullMessage(endpoints: Endpoints, request: PullMessageRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.pullMessage(request, metadata, duration);
+  }
+
+  async updateOffset(endpoints: Endpoints, request: UpdateOffsetRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.updateOffset(request, metadata, duration);
+  }
+
+  async getOffset(endpoints: Endpoints, request: GetOffsetRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.getOffset(request, metadata, duration);
+  }
+
+  async queryOffset(endpoints: Endpoints, request: QueryOffsetRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.queryOffset(request, metadata, duration);
+  }
+
+  async endTransaction(endpoints: Endpoints, request: EndTransactionRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.endTransaction(request, metadata, duration);
+  }
+
+  telemetry(endpoints: Endpoints, metadata: Metadata) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    return rpcClient.telemetry(metadata);
+  }
+
+  async changeInvisibleDuration(endpoints: Endpoints, request: ChangeInvisibleDurationRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.changeInvisibleDuration(request, metadata, duration);
+  }
+
+  async notifyClientTermination(endpoints: Endpoints, request: NotifyClientTerminationRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.notifyClientTermination(request, metadata, duration);
+  }
+
+  async recallMessage(endpoints: Endpoints, request: RecallMessageRequest, duration: number) {
+    const rpcClient = this.#getRpcClient(endpoints);
+    const metadata = this.#baseClient.getRequestMetadata();
+    return await rpcClient.recallMessage(request, metadata, duration);
+  }
+}

package/src/client/SessionCredentials.ts

@@ -0,0 +1,22 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface SessionCredentials {
+  accessKey: string;
+  accessSecret: string;
+  securityToken?: string;
+}

package/src/client/Settings.ts

@@ -0,0 +1,46 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ClientType, Settings as SettingsPB } from '../../proto/apache/rocketmq/v2/definition_pb';
+import { Endpoints } from '../route/Endpoints';
+import { RetryPolicy } from '../retry';
+
+export abstract class Settings {
+  protected readonly namespace: string;
+  protected readonly clientId: string;
+  protected readonly clientType: ClientType;
+  protected readonly accessPoint: Endpoints;
+  protected retryPolicy?: RetryPolicy;
+  protected readonly requestTimeout: number;
+
+  constructor(namespace: string, clientId: string, clientType: ClientType, accessPoint: Endpoints, requestTimeout: number, retryPolicy?: RetryPolicy) {
+    this.clientId = clientId;
+    this.namespace = namespace;
+    this.clientType = clientType;
+    this.accessPoint = accessPoint;
+    this.retryPolicy = retryPolicy;
+    this.requestTimeout = requestTimeout;
+  }
+
+  abstract toProtobuf(): SettingsPB;
+
+  abstract sync(settings: SettingsPB): void;
+
+  getRetryPolicy() {
+    return this.retryPolicy;
+  }
+}

package/src/client/TelemetrySession.ts

@@ -0,0 +1,130 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ClientDuplexStream } from '@grpc/grpc-js';
+import { TelemetryCommand } from '../../proto/apache/rocketmq/v2/service_pb';
+import { Endpoints } from '../route';
+import type { BaseClient } from './BaseClient';
+import { ILogger } from './Logger';
+
+export class TelemetrySession {
+  #endpoints: Endpoints;
+  #baseClient: BaseClient;
+  #logger: ILogger;
+  #stream: ClientDuplexStream<TelemetryCommand, TelemetryCommand>;
+
+  constructor(baseClient: BaseClient, endpoints: Endpoints, logger: ILogger) {
+    this.#endpoints = endpoints;
+    this.#baseClient = baseClient;
+    this.#logger = logger;
+    this.#logger.info('Creating telemetry session, endpoints=%s, clientId=%s',
+      endpoints, baseClient.clientId);
+    this.#renewStream(true);
+  }
+
+  release() {
+    this.#logger.info('Begin to release telemetry session, endpoints=%s, clientId=%s',
+      this.#endpoints, this.#baseClient.clientId);
+    this.#stream.end();
+    this.#stream.removeAllListeners();
+  }
+
+  write(command: TelemetryCommand) {
+    this.#stream.write(command);
+  }
+
+  syncSettings() {
+    const command = this.#baseClient.settingsCommand();
+    this.write(command);
+  }
+
+  #renewStream(inited: boolean) {
+    try {
+      this.#logger.debug?.('Creating telemetry stream, endpoints=%s, clientId=%s, inited=%s',
+        this.#endpoints, this.#baseClient.clientId, inited);
+      this.#stream = this.#baseClient.createTelemetryStream(this.#endpoints);
+      this.#stream.on('data', this.#onData.bind(this));
+      this.#stream.once('error', this.#onError.bind(this));
+      this.#stream.once('end', this.#onEnd.bind(this));
+      if (!inited) {
+        this.#logger.info('Syncing settings to new stream, endpoints=%s, clientId=%s',
+          this.#endpoints, this.#baseClient.clientId);
+        this.syncSettings();
+      }
+    } catch (err) {
+      this.#logger.error('Failed to create telemetry stream, endpoints=%s, clientId=%s, error=%s',
+        this.#endpoints, this.#baseClient.clientId, err);
+      throw err;
+    }
+  }
+
+  #onData(command: TelemetryCommand) {
+    const endpoints = this.#endpoints;
+    const clientId = this.#baseClient.clientId;
+    const commandCase = command.getCommandCase();
+    switch (commandCase) {
+      case TelemetryCommand.CommandCase.SETTINGS:
+        this.#logger.info('Receive settings from remote, endpoints=%s, clientId=%s',
+          endpoints, clientId);
+        this.#baseClient.onSettingsCommand(endpoints, command.getSettings()!);
+        break;
+      case TelemetryCommand.CommandCase.RECOVER_ORPHANED_TRANSACTION_COMMAND: {
+        this.#logger.info('Receive orphaned transaction recovery command from remote, endpoints=%s, clientId=%s',
+          endpoints, clientId);
+        this.#baseClient.onRecoverOrphanedTransactionCommand(endpoints, command.getRecoverOrphanedTransactionCommand()!);
+        break;
+      }
+      case TelemetryCommand.CommandCase.VERIFY_MESSAGE_COMMAND: {
+        this.#logger.info('Receive message verification command from remote, endpoints=%s, clientId=%s',
+          endpoints, clientId);
+        this.#baseClient.onVerifyMessageCommand(endpoints, command.getVerifyMessageCommand()!);
+        break;
+      }
+      case TelemetryCommand.CommandCase.PRINT_THREAD_STACK_TRACE_COMMAND: {
+        this.#logger.info('Receive thread stack print command from remote, endpoints=%s, clientId=%s',
+          endpoints, clientId);
+        this.#baseClient.onPrintThreadStackTraceCommand(endpoints, command.getPrintThreadStackTraceCommand()!);
+        break;
+      }
+      default: {
+        const commandObj = command.toObject();
+        this.#logger.warn('Receive unrecognized command from remote, endpoints=%s, commandCase=%j, command=%j, clientId=%s',
+          endpoints, commandCase, commandObj, clientId);
+        // should telemetry session start fail
+        this.#baseClient.onUnknownCommand(endpoints, commandObj.status!);
+      }
+    }
+  }
+
+  #onError(err: Error) {
+    this.#logger.error('Exception raised from stream response observer, endpoints=%s, clientId=%s, error=%s',
+      this.#endpoints, this.#baseClient.clientId, err);
+    this.release();
+    setTimeout(() => {
+      this.#renewStream(false);
+    }, 1000);
+  }
+
+  #onEnd() {
+    this.#logger.info('Receive completion for stream response observer, endpoints=%s, clientId=%s',
+      this.#endpoints, this.#baseClient.clientId);
+    this.release();
+    setTimeout(() => {
+      this.#renewStream(false);
+    }, 1000);
+  }
+}

package/src/client/UserAgent.ts

@@ -0,0 +1,45 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { UA, Language } from '../../proto/apache/rocketmq/v2/definition_pb';
+
+const VERSION: string = JSON.parse(readFileSync(path.join(__dirname, '../../package.json'), 'utf-8')).version;
+
+export class UserAgent {
+  static readonly INSTANCE = new UserAgent(VERSION, os.platform(), os.hostname());
+
+  readonly version: string;
+  readonly platform: string;
+  readonly hostname: string;
+
+  constructor(version: string, platform: string, hostname: string) {
+    this.version = version;
+    this.platform = platform;
+    this.hostname = hostname;
+  }
+
+  toProtobuf() {
+    return new UA()
+      .setLanguage(Language.NODE_JS)
+      .setVersion(this.version)
+      .setPlatform(this.platform)
+      .setHostname(this.hostname);
+  }
+}