Generated clients seem to not send certain message fields

[Doryanni]

I've been experimenting with gRPC and nestjs and am trying to set up a logging microservice that receives rpc calls with the contents of logs. These last few days I've been stumped by a peculiar phenomenon, where the data sent through the protobuf-ts's generated clients have missing fields when received by the nestjs microservice. For example:

Here is my .proto file:

/**
* Definitions of shared interfaces 
**/

syntax = "proto3";

package logs;

enum LogLevel {
  INFO = 0;
  WARN = 1;
  ERROR = 2;
  DEBUG = 3;
}

message LogContext {
  string sessionId = 1;
  string requestId = 2;
  string hostname = 3;
  string podName = 4;
  string grpcMethodName = 5;
  uint32 durationMs = 6;
}

message ErrorData {
  string name = 1;
  string notificationCode = 2;
  string stack = 3;
}

message CreateLogRequest {
  LogLevel level = 1;
  string service = 2;
  uint64 timestamp = 3;
  string message = 4;
  LogContext context = 5;
  ErrorData errorData = 6;
}

message CreateLogResponse {
  LogLevel level = 1;
  string service = 2;
  int32 code = 3;
}

service LogService {
  rpc CreateLog (CreateLogRequest) returns (CreateLogResponse) {}
}

My client looks like this:

...

import { GrpcTransport } from '@protobuf-ts/grpc-transport';
import { ChannelCredentials } from '@grpc/grpc-js';


export interface HmsLoggerOptions {
  podName: string;
  serviceName: string;
  address: string;
}

export class Logger {
  private _loggingClient: LogServiceClient;
  private _podName: string;
  private _serviceName: string;

  constructor(
    private _localStorageInstance: AsyncLocalStorage<BaseLoggingLocalStorage>,
    options: HmsLoggerOptions,
  ) {
    const { podName, serviceName, address } = options;

    this._podName = podName;
    this._serviceName = serviceName;

    const transport = new GrpcTransport({
      host: address,
      channelCredentials: ChannelCredentials.createInsecure(),
    });
    this._loggingClient = new LogServiceClient(transport);
  }

  private _createLog(
    level: LogLevel,
    message: string,
    errorData: Record<string, unknown> = {},
  ): Promise<CreateLogResponse> {
    const storage = this._localStorageInstance.getStore();
    const {
      sessionId = '',
      requestId = '',
      hostname = '*',
      grpcMethodName = '',
    } = storage?.context ?? {};

    const context: LogContext = {
      sessionId,
      requestId,
      hostname,
      grpcMethodName,
      podName: this._podName,
      durationMs: 0,
    };

    const parsedErrorData: ErrorData | undefined =
      extractLogErrorData(errorData);

    const logRequestObj: CreateLogRequest = {
      level,
      service: this._serviceName,
      message,
      timestamp: BigInt(new Date().getTime()),
      context,
      errorData: parsedErrorData,
    };

    const logRequest = CreateLogRequest.create(logRequestObj);

    return this._loggingClient.createLog(logRequest).response;
  }

  info(msg: string): Promise<CreateLogResponse> {
    console.info(msg);
    return this._createLog(LogLevel.INFO, msg);
  }

  warn(msg: string): Promise<CreateLogResponse> {
    console.warn(msg);
    return this._createLog(LogLevel.WARN, msg);
  }

  error(
    msg: string,
    error: Record<string, unknown> | undefined,
  ): Promise<CreateLogResponse> {
    console.error(msg, error);
    return this._createLog(LogLevel.ERROR, msg, error ?? {});
  }

  debug(msg: string): Promise<CreateLogResponse> {
    console.debug(msg);
    return this._createLog(LogLevel.DEBUG, msg);
  }

}

But whenever I call Logger.info, the microservice does not receive the level field (and certain fields of the context object).
However, if I send a request using Postman, everything works alright! So I reach the conclusion that I'm setting the client wrong or that it has issues.

P.S. Upon further investigation, it seems that the client does not send nullish? values specifically (values like '', or 0).

[jcready]

https://developers.google.com/protocol-buffers/docs/proto3#default

Also note that if a scalar message field is set to its default, the value will not be serialized on the wire.