@google-cloud/logging

constructor

constructor(metadata?: LogEntry, data?: any);

property data

data: any;

property metadata

metadata: LogEntry;

method fromApiResponse_

static fromApiResponse_: (entry: google.logging.v2.LogEntry) => Entry;

• Create an Entry object from an API response, such as entries:list.

  Parameter entry

  An API representation of an entry. See a LogEntry.

  Returns

  {Entry}

method toJSON

toJSON: (options?: ToJsonOptions, projectId?: string) => EntryJson;

• Serialize an entry to the format the API expects. Read more: https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry

  Parameter options

  Configuration object.

  Parameter

  {boolean} [options.removeCircular] Replace circular references in an object with a string value, [Circular].

  Parameter projectId

  GCP Project ID.

method toStructuredJSON

toStructuredJSON: (
    projectId?: string,
    useMessageField?: boolean
) => StructuredJson;

• Serialize an entry to a standard format for any transports, e.g. agents. Read more: https://cloud.google.com/logging/docs/structured-logging

constructor

constructor(logging: Logging, name: string, options?: LogOptions);

property defaultWriteDeleteCallback

defaultWriteDeleteCallback?: ApiResponseCallback;

property formattedName_

formattedName_: string;

property jsonFieldsToTruncate

jsonFieldsToTruncate: string[];

property logging

logging: Logging;

property maxEntrySize

maxEntrySize?: number;

property name

name: string;

property partialSuccess

partialSuccess: boolean;

property removeCircular_

removeCircular_: boolean;

method alert

alert: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "ALERT".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.alert(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.alert(entry).then(data => {
    const apiResponse = data[0];
  });

method assignSeverityToEntries_

static assignSeverityToEntries_: (
    entries: Entry | Entry[],
    severity: string
) => Entry[];

• Return an array of log entries with the desired severity assigned.

  Parameter entries

  Log entries.

  Parameter severity

  The desired severity level.

method critical

critical: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "CRITICAL".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.critical(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.critical(entry).then(data => {
    const apiResponse = data[0];
  });

method debug

debug: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "DEBUG".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.debug(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.debug(entry).then(data => {
    const apiResponse = data[0];
  });

method delete

delete: {
    (gaxOptions?: CallOptions): Promise<ApiResponse>;
    (gaxOptions: CallOptions, callback: ApiResponseCallback): void;
    (callback: ApiResponseCallback): void;
};

• Delete the log.

  See projects.logs.delete API Documentation

  Parameter gaxOptions

  Request configuration options, outlined here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  log.delete((err, apiResponse) => {
    if (!err) {
      // The log was deleted.
    }
  });
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.delete().then(data => {
    const apiResponse = data[0];
  });

  Example 2

  include:samples/logs.js region_tag:logging_delete_log Another example:

method emergency

emergency: {
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "EMERGENCY".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.emergency(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.emergency(entry).then(data => {
    const apiResponse = data[0];
  });

method entry

entry: {
    (metadata?: LogEntry): Entry;
    (data?: string | {}): Entry;
    (metadata?: LogEntry, data?: string | {}): Entry;
};

• Create an entry object for this log.

  Using this method will not itself make any API requests. You will use the object returned in other API calls, such as Log#write.

  Note, Cloud Logging Quotas and limits dictates that the maximum log entry size, including all [LogEntry Resource properties]https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry, cannot exceed _approximately_ 256 KB.

  See LogEntry JSON representation

  Parameter metadata

  See a [LogEntry Resource](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry).

  Parameter data

  The data to use as the value for this log entry.

  Returns

  {Entry}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const metadata = {
    resource: {
      type: 'gce_instance',
      labels: {
        zone: 'global',
        instance_id: '3'
      }
    }
  };
  
  const entry = log.entry(metadata, {
    delegate: 'my_username'
  });
  
  entry.toJSON();
  // {
  //   logName: 'projects/grape-spaceship-123/logs/syslog',
  //   resource: {
  //     type: 'gce_instance',
  //     labels: {
  //       zone: 'global',
  //       instance_id: '3'
  //     }
  //   },
  //   jsonPayload: {
  //     delegate: 'my_username'
  //   }
  // }

method error

error: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "ERROR".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.error(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.error(entry).then(data => {
    const apiResponse = data[0];
  });

method formatName_

static formatName_: (projectId: string, name: string) => string;

• Format the name of a log. A log's full name is in the format of 'projects/{projectId}/logs/{logName}'.

  Returns

  {string}

method getEntries

getEntries: {
    (options?: GetEntriesRequest): Promise<GetEntriesResponse>;
    (callback: GetEntriesCallback): void;
    (options: GetEntriesRequest, callback: GetEntriesCallback): void;
};

• This method is a wrapper around {module:logging#getEntries}, but with a filter specified to only return entries from this log.

  See entries.list API Documentation

  Parameter query

  Query object for listing entries.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  log.getEntries((err, entries) => {
    // `entries` is an array of Cloud Logging entry objects.
    // See the `data` property to read the data from the entry.
  });
  
  //-
  // To control how many API requests are made and page through the results
  // manually, set `autoPaginate` to `false`.
  //-
  function callback(err, entries, nextQuery, apiResponse) {
    if (nextQuery) {
      // More results exist.
      log.getEntries(nextQuery, callback);
    }
  }
  
  log.getEntries({
    autoPaginate: false
  }, callback);
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.getEntries().then(data => {
    const entries = data[0];
  });

method getEntriesStream

getEntriesStream: (options: GetEntriesRequest) => any;

• This method is a wrapper around {module:logging#getEntriesStream}, but with a filter specified to only return {module:logging/entry} objects from this log.

  Log#getEntriesStream

  Parameter query

  Query object for listing entries.

  Returns

  {ReadableStream} A readable stream that emits Entry instances.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  log.getEntriesStream()
    .on('error', console.error)
    .on('data', entry => {
      // `entry` is a Cloud Logging entry object.
      // See the `data` property to read the data from the entry.
    })
    .on('end', function() {
      // All entries retrieved.
    });
  
  //-
  // If you anticipate many results, you can end a stream early to prevent
  // unnecessary processing and API requests.
  //-
  log.getEntriesStream()
    .on('data', function(entry) {
      this.end();
    });

method info

info: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "INFO".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.info(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.info(entry).then(data => {
    const apiResponse = data[0];
  });

method notice

notice: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "NOTICE".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.notice(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.notice(entry).then(data => {
    const apiResponse = data[0];
  });

method tailEntries

tailEntries: (options?: TailEntriesRequest) => any;

• This method is a wrapper around {module:logging#tailEntries}, but with a filter specified to only return {module:logging/entry} objects from this log.

  Log#tailEntries

  Parameter query

  Query object for tailing entries.

  Returns

  {DuplexStream} A duplex stream that emits TailEntriesResponses containing an array of Entry instances.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  log.tailEntries()
    .on('error', console.error)
    .on('data', resp => {
      console.log(resp.entries);
      console.log(resp.suppressionInfo);
    })
    .on('end', function() {
      // All entries retrieved.
    });
  
  //-
  // If you anticipate many results, you can end a stream early to prevent
  // unnecessary processing and API requests.
  //-
  log.tailEntries()
    .on('data', function(entry) {
      this.end();
    });

method warning

warning: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write a log entry with a severity of "WARNING".

  This is a simple wrapper around Log.write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.warning(entry, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.warning(entry).then(data => {
    const apiResponse = data[0];
  });

method write

write: {
    (entry: Entry | Entry[], options?: WriteOptions): Promise<ApiResponse>;
    (
        entry: Entry | Entry[],
        options: WriteOptions,
        callback: ApiResponseCallback
    ): void;
    (entry: Entry | Entry[], callback: ApiResponseCallback): void;
};

• Write log entries to Cloud Logging.

  Note, Cloud Logging Quotas and limits dictates that the maximum cumulative size of all entries per write, including all [LogEntry Resource properties]https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry, cannot exceed _approximately_ 10 MB.

  See entries.write API Documentation

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.write(entry, (err, apiResponse) => {
    if (!err) {
      // The log entry was written.
    }
  });
  
  //-
  // You may also pass multiple log entries to write.
  //-
  const secondEntry = log.entry('compute.googleapis.com', {
    user: 'my_username'
  });
  
  log.write([
    entry,
    secondEntry
  ], (err, apiResponse) => {
    if (!err) {
      // The log entries were written.
    }
  });
  
  //-
  // To save some steps, you can also pass in plain values as your entries.
  // Note, however, that you must provide a configuration object to specify
  // the resource.
  //-
  const entries = [
    {
      user: 'my_username'
    },
    {
      home: process.env.HOME
    }
  ];
  
  const options = {
    resource: 'compute.googleapis.com'
  };
  
  log.write(entries, options, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  log.write(entries).then(data => {
    const apiResponse = data[0];
  });

  Example 2

  include:samples/logs.js region_tag:logging_write_log_entry Another example:

  Example 3

  include:samples/logs.js region_tag:logging_write_log_entry_advanced Another example:

constructor

constructor(options?: LoggingOptions, gaxInstance?: any);

property api

api: { [key: string]: gax.ClientStub };

property auth

auth: gax.GoogleAuth;

property configService

configService?: any;

property detectedResource

detectedResource?: {};

property loggingService

loggingService?: any;

property options

options: LoggingOptions;

property projectId

projectId: string;

method createSink

createSink: {
    (name: string, config: CreateSinkRequest): Promise<[Sink, LogSink]>;
    (
        name: string,
        config: CreateSinkRequest,
        callback: CreateSinkCallback
    ): void;
};

• CreateSinkCallback

  Parameter err

  Request error, if any.

  Parameter sink

  The new Sink.

  Parameter apiResponse

  The full API response.

method entry

entry: (resource?: LogEntry, data?: {} | string) => Entry;

• Create an entry object.

  Using this method will not itself make any API requests. You will use the object returned in other API calls, such as Log#write.

  Note, Cloud Logging Quotas and limits dictates that the maximum log entry size, including all [LogEntry Resource properties]https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry, cannot exceed _approximately_ 256 KB.

  See LogEntry JSON representation

  Parameter resource

  See a [Monitored Resource](https://cloud.google.com/logging/docs/reference/v2/rest/v2/MonitoredResource).

  Parameter data

  The data to use as the value for this log entry.

  Returns

  {Entry}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  const resource = {
    type: 'gce_instance',
    labels: {
      zone: 'global',
      instance_id: '3'
    }
  };
  
  const entry = logging.entry(resource, {
    delegate: 'my_username'
  });
  
  entry.toJSON();
  // {
  //   resource: {
  //     type: 'gce_instance',
  //     labels: {
  //       zone: 'global',
  //       instance_id: '3'
  //     }
  //   },
  //   jsonPayload: {
  //     delegate: 'my_username'
  //   }
  // }

method getEntries

getEntries: {
    (options?: GetEntriesRequest): Promise<GetEntriesResponse>;
    (callback: GetEntriesCallback): void;
    (options: GetEntriesRequest, callback: GetEntriesCallback): void;
};

• List the entries in your logs.

  See entries.list API Documentation

  Parameter query

  Query object for listing entries.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.getEntries((err, entries) => {
    // `entries` is an array of Cloud Logging entry objects.
    // See the `data` property to read the data from the entry.
  });
  
  //-
  // To control how many API requests are made and page through the results
  // manually, set `autoPaginate` to `false`.
  //-
  function callback(err, entries, nextQuery, apiResponse) {
    if (nextQuery) {
      // More results exist.
      logging.getEntries(nextQuery, callback);
    }
  }
  
  logging.getEntries({
    autoPaginate: false
  }, callback);
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  logging.getEntries().then(data => {
    const entries = data[0];
  });

  Example 2

  include:samples/logs.js region_tag:logging_list_log_entries Another example:

  Example 3

  include:samples/logs.js region_tag:logging_list_log_entries_advanced Another example:

method getEntriesStream

getEntriesStream: (options?: GetEntriesRequest) => Duplex;

• List the Entry objects in your logs as a readable object stream.

  Logging#getEntriesStream

  Parameter query

  Query object for listing entries.

  Returns

  {ReadableStream} A readable stream that emits Entry instances.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.getEntriesStream()
    .on('error', console.error)
    .on('data', entry => {
      // `entry` is a Cloud Logging entry object.
      // See the `data` property to read the data from the entry.
    })
    .on('end', function() {
      // All entries retrieved.
    });
  
  //-
  // If you anticipate many results, you can end a stream early to prevent
  // unnecessary processing and API requests.
  //-
  logging.getEntriesStream()
    .on('data', function(entry) {
      this.end();
    });

method getLogs

getLogs: {
    (options?: GetLogsRequest): Promise<GetLogsResponse>;
    (callback: GetLogsCallback): void;
    (options: GetLogsRequest, callback: GetLogsCallback): void;
};

• List the entries in your logs.

  See logs.list API Documentation

  Parameter query

  Query object for listing entries.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.getLogs((err, logs) => {
    // `logs` is an array of Cloud Logging log objects.
  });
  
  //-
  // To control how many API requests are made and page through the results
  // manually, set `autoPaginate` to `false`.
  //-
  function callback(err, entries, nextQuery, apiResponse) {
    if (nextQuery) {
      // More results exist.
      logging.getLogs(nextQuery, callback);
    }
  }
  
  logging.getLogs({
    autoPaginate: false
  }, callback);
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  logging.getLogs().then(data => {
    const entries = data[0];
  });

  Example 2

  include:samples/logs.js region_tag:logging_list_logs Another example:

method getLogsStream

getLogsStream: (options?: GetLogsRequest) => Duplex;

• List the Log objects in your project as a readable object stream.

  Logging#getLogsStream

  Parameter query

  Query object for listing entries.

  Returns

  {ReadableStream} A readable stream that emits Log instances.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.getLogsStream()
    .on('error', console.error)
    .on('data', log => {
      // `log` is a Cloud Logging log object.
    })
    .on('end', function() {
      // All logs retrieved.
    });
  
  //-
  // If you anticipate many results, you can end a stream early to prevent
  // unnecessary processing and API requests.
  //-
  logging.getLogsStream()
    .on('data', log => {
      this.end();
    });

method getSinks

getSinks: {
    (options?: GetSinksRequest): Promise<GetSinksResponse>;
    (callback: GetSinksCallback): void;
    (options: GetSinksRequest, callback: GetSinksCallback): void;
};

• Get the sinks associated with this project.

  See projects.sinks.list API Documentation

  Parameter query

  Query object for listing sinks.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.getSinks((err, sinks) => {
    // sinks is an array of Sink objects.
  });
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  logging.getSinks().then(data => {
    const sinks = data[0];
  });

  Example 2

  include:samples/sinks.js region_tag:logging_list_sinks Another example:

method getSinksStream

getSinksStream: (options: GetSinksRequest) => Duplex;

• Get the Sink objects associated with this project as a readable object stream.

  Logging#getSinksStream

  Parameter query

  Query object for listing sinks.

  Returns

  {ReadableStream} A readable stream that emits Sink instances.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.getSinksStream()
    .on('error', console.error)
    .on('data', sink => {
      // `sink` is a Sink object.
    })
    .on('end', function() {
      // All sinks retrieved.
    });
  
  //-
  // If you anticipate many results, you can end a stream early to prevent
  // unnecessary processing and API requests.
  //-
  logging.getSinksStream()
    .on('data', function(sink) {
      this.end();
    });

method log

log: (name: string, options?: LogOptions) => Log;

• Get a reference to a Cloud Logging log.

  See Log Overview

  Parameter name

  Name of the existing log.

  Parameter options

  Configuration object.

  Parameter

  {boolean} [options.removeCircular] Replace circular references in logged objects with a string value, [Circular]. (Default: false)

  Returns

  {Log}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.log('my-log');

method logSync

logSync: (
    name: string,
    transport?: Writable,
    options?: LogSyncOptions
) => LogSync;

• Get a reference to a Cloud Logging logSync.

  Parameter name

  Name of the existing log.

  Parameter transport

  An optional write stream.

  Parameter options

  An optional configuration object.

  Returns

  {LogSync}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  // Optional: enrich logs with additional context
  await logging.setProjectId();
  await logging.setDetectedResource();
  
  // Default transport writes to process.stdout
  const log = logging.logSync('my-log');

method request

request: <TResponse = any>(
    config: RequestConfig,
    callback?: RequestCallback<TResponse>
) => Duplex;

• Funnel all API requests through this method, to be sure we have a project ID.

  Parameter config

  Configuration object.

  Parameter

  {object} config.gaxOpts GAX options.

  Parameter

  {function} config.method The gax method to call.

  Parameter

  {object} config.reqOpts Request options.

  Parameter callback

  Callback function.

method setAclForBucket_

setAclForBucket_: (config: CreateSinkRequest) => Promise<void>;

• This method is called when creating a sink with a Bucket destination. The bucket must first grant proper ACL access to the Cloud Logging account.

  The parameters are the same as what Logging#createSink accepts.

method setAclForDataset_

setAclForDataset_: (config: CreateSinkRequest) => Promise<void>;

• This method is called when creating a sink with a Dataset destination. The dataset must first grant proper ACL access to the Cloud Logging account.

  The parameters are the same as what Logging#createSink accepts.

method setAclForTopic_

setAclForTopic_: (config: CreateSinkRequest) => Promise<void>;

• This method is called when creating a sink with a Topic destination. The topic must first grant proper ACL access to the Cloud Logging account.

  The parameters are the same as what Logging#createSink accepts.

method setDetectedResource

setDetectedResource: () => Promise<void>;

• setResource detects and sets a detectedresource object on the Logging instance. It can be invoked once to ensure ensuing LogSync entries contain resource context.

method setProjectId

setProjectId: (reqOpts?: {}) => Promise<void>;

• setProjectId detects and sets a projectId string on the Logging instance. It can be invoked once to ensure ensuing LogSync entries have a projectID.

  Parameter reqOpts

method sink

sink: (name: string) => Sink;

• Get a reference to a Cloud Logging sink.

  See Sink Overview

  Parameter name

  Name of the existing sink.

  Returns

  {Sink}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const sink = logging.sink('my-sink');

method tailEntries

tailEntries: (options?: TailEntriesRequest) => Duplex;

• Streaming read of live logs as log entries are ingested. Until the stream is terminated, it will continue reading logs.

  Logging#tailEntries

  Parameter query

  Query object for tailing entries.

  Returns

  {DuplexStream} A duplex stream that emits TailEntriesResponses containing an array of Entry instances.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  
  logging.tailEntries()
    .on('error', console.error)
    .on('data', resp => {
      console.log(resp.entries);
      console.log(resp.suppressionInfo);
    })
    .on('end', function() {
      // All entries retrieved.
    });
  
  //-
  // If you anticipate many results, you can end a stream early to prevent
  // unnecessary processing and API requests.
  //-
  logging.getEntriesStream()
    .on('data', function(entry) {
      this.end();
    });

constructor

constructor(
    logging: Logging,
    name: string,
    transport?: Writable,
    options?: LogSyncOptions
);

property formattedName_

formattedName_: string;

property logging

logging: Logging;

property name

name: string;

property transport

transport: Writable;

property useMessageField_

useMessageField_: boolean;

method alert

alert: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "ALERT".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.alert(entry);

method critical

critical: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "CRITICAL".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.critical(entry);

method debug

debug: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "DEBUG".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.debug(entry);

method emergency

emergency: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "EMERGENCY".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.emergency(entry);

method entry

entry: {
    (metadata?: LogEntry): Entry;
    (data?: string | {}): Entry;
    (metadata?: LogEntry, data?: string | {}): Entry;
};

• Create an entry object for this log.

  Using this method will not itself do any logging.

  See LogEntry JSON representation

  Parameter metadata

  See a [LogEntry Resource](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry).

  Parameter data

  The data to use as the value for this log entry.

  Returns

  {Entry}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const metadata = {
    resource: {
      type: 'gce_instance',
      labels: {
        zone: 'global',
        instance_id: '3'
      }
    }
  };
  
  const entry = log.entry(metadata, {
    delegate: 'my_username'
  });

method error

error: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "ERROR".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.error(entry);

method info

info: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "INFO".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.info(entry);

method notice

notice: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "NOTICE".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.notice(entry);

method warning

warning: (entry: Entry | Entry[], options?: WriteOptions) => void;

• Write a log entry with a severity of "WARNING".

  This is a simple wrapper around LogSync#write. All arguments are the same as documented there.

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const log = logging.logSync('my-log');
  
  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.warning(entry);

method write

write: (entry: Entry | Entry[], opts?: WriteOptions) => void;

• Write log entries to a custom transport (default: process.stdout).

  Parameter entry

  A log entry, or array of entries, to write.

  Parameter options

  Write options

  Example 1

  const entry = log.entry('gce_instance', {
    instance: 'my_instance'
  });
  
  log.write(entry);
  
  //-
  // You may also pass multiple log entries to write.
  //-
  const secondEntry = log.entry('compute.googleapis.com', {
    user: 'my_username'
  });
  
  log.write([entry, secondEntry]);
  
  //-
  // To save some steps, you can also pass in plain values as your entries.
  // Note, however, that you must provide a configuration object to specify
  // the resource.
  //-
  const entries = [
    {
      user: 'my_username'
    },
    {
      home: process.env.HOME
    }
  ];
  
  const options = {
    resource: 'compute.googleapis.com'
  };
  
  log.write(entries, options);
  
  log.write(entries);
  });

constructor

constructor(logging: Logging, name: string);

property formattedName_

formattedName_: string;

property logging

logging: Logging;

property metadata

metadata?: google.logging.v2.ILogSink;

property name

name: string;

method create

create: {
    (config: CreateSinkRequest): Promise<[Sink, LogSink]>;
    (config: CreateSinkRequest, callback: CreateSinkCallback): void;
};

• Create a sink.

  Parameter config

  Config to set for the sink.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Throws

  {Error} if a config object is not provided.

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const sink = logging.sink('my-sink');
  
  const config = {
    destination: {
      // ...
    }
  };
  
  sink.create(config, (err, sink, apiResponse) => {
    if (!err) {
      // The sink was created successfully.
    }
  });
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  sink.create(config).then(data => {
    const sink = data[0];
    const apiResponse = data[1];
  });

  Example 2

  include:samples/sinks.js region_tag:logging_create_sink Another example:

  See Also

  • Logging#createSink

method delete

delete: {
    (gaxOptions?: CallOptions): Promise<DeleteResponse>;
    (callback: DeleteCallback): void;
    (gaxOptions: CallOptions, callback: DeleteCallback): void;
};

• Delete the sink.

  See projects.sink.delete API Documentation

  Parameter gaxOptions

  Request configuration options, outlined here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const sink = logging.sink('my-sink');
  
  sink.delete((err, apiResponse) => {
    if (!err) {
      // The log was deleted.
    }
  });
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  sink.delete().then(data => {
    const apiResponse = data[0];
  });

  Example 2

  include:samples/sinks.js region_tag:logging_delete_sink Another example:

method getMetadata

getMetadata: {
    (gaxOptions?: CallOptions): Promise<SinkMetadataResponse>;
    (callback: SinkMetadataCallback): void;
    (gaxOptions: CallOptions, callback: SinkMetadataCallback): void;
};

• Get the sink's metadata.

  See Sink Resource See projects.sink.get API Documentation

  Parameter gaxOptions

  Request configuration options, outlined here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const sink = logging.sink('my-sink');
  
  sink.getMetadata((err, metadata, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  sink.getMetadata().then(data => {
    const metadata = data[0];
  });

  Example 2

  include:samples/sinks.js region_tag:logging_get_sink Another example:

method setFilter

setFilter: {
    (filter: string): Promise<SinkMetadataResponse>;
    (filter: string, callback: SinkMetadataCallback): void;
};

• Set the sink's filter.

  This will override any filter that was previously set.

  See Advanced Logs Filters

  Parameter filter

  The new filter.

  Parameter callback

  Callback function.

  Returns

  {Promise}

  Example 1

  const {Logging} = require('@google-cloud/logging');
  const logging = new Logging();
  const sink = logging.sink('my-sink');
  
  const filter = 'metadata.severity = ALERT';
  
  sink.setFilter(filter, (err, apiResponse) => {});
  
  //-
  // If the callback is omitted, we'll return a Promise.
  //-
  sink.setFilter(filter).then(data => {
    const apiResponse = data[0];
  });

method setMetadata