INVALID_ARGUMENT: Log entry with size NK exceeds maximum size of YK

INVALID_ARGUMENT: Log entry with size NK exceeds maximum size of YK

The error message "INVALID_ARGUMENT: Log entry with size 789.3K exceeds maximum size of 256.0K" indicates that you are trying to log an entry that exceeds the maximum allowed size for a log entry in Google Cloud Logging.

In Google Cloud Logging, each log entry has a size limit, and the default maximum size is 256 KB. If you attempt to log an entry that surpasses this limit, you will encounter the "INVALID_ARGUMENT" error you mentioned.

To resolve this issue, you should truncate the object that you are passing to the GCP Log

Change in your code:
Add truncateObject() like this:

Here are the full codes

                    /* eslint-disable no-console */
                    import { Logging } from '@google-cloud/logging';
                    import { Injectable } from '@nestjs/common';
                    
                    class CloudLoggerDTO {
                      service?: string;
                      userId?: string;
                      hostname?: string;
                      correlationId?: string;
                      requestId?: string;
                      timestamp?: string;
                      methodName?: string;
                      callStack?: string;
                      requestMethod?: string;
                      requestURI?: string;
                    }
                    
                    @Injectable()
                    export class CloudLoggerService {
                      private logging: Logging;
                      private severityLog = 'NOTICE';
                      private severityError = 'ERROR';
                      private severityWarn = 'WARNING';
                      private resource: any = { type: 'global' };
                      private serviceName: string;
                      private logName: string;
                      private env: string;
                      private projectId: string;
                      private logSize: number;
                    
                      constructor() {
                        this.projectId = 'PROJECT_ID';
                        this.logging = new Logging({ projectId: this.projectId });
                        this.logName = 'LOG NAME';
                        this.logSize = 256;
                      }
                    
                      log(message: string, other: CloudLoggerDTO = {}): void {
                        try {
                          const messageInfo = this.getMessageInfo(message, other);
                          const metadataLog = this.getMetaData(this.severityLog);
                          const log = this.logging.log(this.logName, this.resource);
                          const entry = this.logging.entry(metadataLog, messageInfo);
                          log.write(entry);
                        } catch (err) {
                          console.log('Exception in log()', err);
                        }
                      }
                    
                      error(message: string, other: CloudLoggerDTO = {}): any {
                        try {
                          const messageInfo = this.getMessageInfo(message, other);
                          const metadataLog = this.getMetaData(this.severityError);
                          const log = this.logging.log(this.logName, this.resource);
                          const entry = this.logging.entry(metadataLog, messageInfo);
                          log.write(entry);
                          return;
                        } catch (err) {
                          console.log('Exception in info()', err);
                        }
                      }
                    
                    
                      getMessageInfo(message: string, other: CloudLoggerDTO) {
                        return {
                          message,
                          service: this.serviceName,
                          env: this.env,
                          logName: this.logName,
                          projectId: this.projectId,
                          timeStamp: new Date(),
                          ...this.truncateObject(other),
                        };
                      }
                    
                      getMetaData(severity) {
                        return {
                          severity,
                          resource: this.resource,
                        };
                      }
                    
                      /* This logic will remove the error: INVALID_ARGUMENT: Log entry with size 789.3K exceeds maximum size of 256.0K */
                      truncateObject(obj) {
                      if (obj && obj.error) {
                        obj.error = this.stringifyCircularJSON(obj.error).substring(0, (Number(this.logSize) - 56) * 1024);
                      }
                      if (obj && obj.request) {
                        obj.request = this.stringifyCircularJSON(obj.request).substring(0, 30 * 1024);
                      }
                      if (obj && obj.callStack) {
                        obj.callStack = this.stringifyCircularJSON(obj.callStack).substring(0, 26 * 1024);
                      }
                      return obj;
                    }
                    
                    stringifyCircularJSON(obj: any) {
                      const seen = new Set();
                      const jsonString = JSON.stringify(obj, (key, value) => { if (typeof value === 'object' && value !== null) { if (seen.has(value)) { return '[Circular Reference]'; } seen.add(value); } return value; });
                      return jsonString;
                    }
                    }
                        

---

Conclusion:

Adjust the code according to your specific logging setup and language environment. The key is to ensure that your log entries are within the allowed size limits.

Related Keywords:

INVALID_ARGUMENT: Log entry with size NK exceeds maximum size of YK

INVALID_ARGUMENT: Log entry with size, exceeds maximum size

GCP Logging: Exception is thrown when log entries > 256kb