googleapis
Version:
Google APIs Client Library for Node.js
396 lines (395 loc) • 18.1 kB
TypeScript
/**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed 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 { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
* Stackdriver Trace API
*
* Sends application trace data to Stackdriver Trace for viewing. Trace data is
* collected for all App Engine applications by default. Trace data from other
* applications can be provided using this API.
*
* @example
* const google = require('googleapis');
* const cloudtrace = google.cloudtrace('v1');
*
* @namespace cloudtrace
* @type {Function}
* @version v1
* @variation v1
* @param {object=} options Options for Cloudtrace
*/
export declare class Cloudtrace {
_options: GlobalOptions;
google: GoogleApis;
root: this;
projects: Resource$Projects;
constructor(options: GlobalOptions, google: GoogleApis);
getRoot(): this;
}
/**
* A generic empty message that you can re-use to avoid defining duplicated
* empty messages in your APIs. A typical example is to use it as the request or
* the response type of an API method. For instance: service Foo { rpc
* Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON
* representation for `Empty` is empty JSON object `{}`.
*/
export interface Schema$Empty {
}
/**
* The response message for the `ListTraces` method.
*/
export interface Schema$ListTracesResponse {
/**
* If defined, indicates that there are more traces that match the request and
* that this value should be passed to the next request to continue retrieving
* additional traces.
*/
nextPageToken: string;
/**
* List of trace records returned.
*/
traces: Schema$Trace[];
}
/**
* A trace describes how long it takes for an application to perform an
* operation. It consists of a set of spans, each of which represent a single
* timed event within the operation.
*/
export interface Schema$Trace {
/**
* Project ID of the Cloud project where the trace data is stored.
*/
projectId: string;
/**
* Collection of spans in the trace.
*/
spans: Schema$TraceSpan[];
/**
* Globally unique identifier for the trace. This identifier is a 128-bit
* numeric value formatted as a 32-byte hex string.
*/
traceId: string;
}
/**
* List of new or updated traces.
*/
export interface Schema$Traces {
/**
* List of traces.
*/
traces: Schema$Trace[];
}
/**
* A span represents a single timed event within a trace. Spans can be nested
* and form a trace tree. Often, a trace contains a root span that describes the
* end-to-end latency of an operation and, optionally, one or more subspans for
* its suboperations. Spans do not need to be contiguous. There may be gaps
* between spans in a trace.
*/
export interface Schema$TraceSpan {
/**
* End time of the span in nanoseconds from the UNIX epoch.
*/
endTime: string;
/**
* Distinguishes between spans generated in a particular context. For example,
* two spans with the same name may be distinguished using `RPC_CLIENT` and
* `RPC_SERVER` to identify queueing latency associated with the span.
*/
kind: string;
/**
* Collection of labels associated with the span. Label keys must be less than
* 128 bytes. Label values must be less than 16 kilobytes (10MB for
* `/stacktrace` values). Some predefined label keys exist, or you may create
* your own. When creating your own, we recommend the following formats: *
* `/category/product/key` for agents of well-known products (e.g.
* `/db/mongodb/read_size`). * `short_host/path/key` for domain-specific keys
* (e.g. `foo.com/myproduct/bar`) Predefined labels include: * `/agent`
* * `/component` * `/error/message` * `/error/name` *
* `/http/client_city` * `/http/client_country` * `/http/client_protocol`
* * `/http/client_region` * `/http/host` * `/http/method` *
* `/http/path` * `/http/redirected_url` * `/http/request/size` *
* `/http/response/size` * `/http/route` * `/http/status_code` *
* `/http/url` * `/http/user_agent` * `/pid` * `/stacktrace` * `/tid`
*/
labels: any;
/**
* Name of the span. Must be less than 128 bytes. The span name is sanitized
* and displayed in the Stackdriver Trace tool in the {% dynamic print
* site_values.console_name %}. The name may be a method name or some other
* per-call site name. For the same executable and the same call point, a best
* practice is to use a consistent name, which makes it easier to correlate
* cross-trace spans.
*/
name: string;
/**
* ID of the parent span, if any. Optional.
*/
parentSpanId: string;
/**
* Identifier for the span. Must be a 64-bit integer other than 0 and unique
* within a trace.
*/
spanId: string;
/**
* Start time of the span in nanoseconds from the UNIX epoch.
*/
startTime: string;
}
export declare class Resource$Projects {
root: Cloudtrace;
traces: Resource$Projects$Traces;
constructor(root: Cloudtrace);
getRoot(): Cloudtrace;
/**
* cloudtrace.projects.patchTraces
* @desc Sends new traces to Stackdriver Trace or updates existing traces. If
* the ID of a trace that you send matches that of an existing trace, any
* fields in the existing trace and its spans are overwritten by the provided
* values, and any new fields provided are merged with the existing trace
* data. If the ID does not match, a new trace is created.
* @example
* * // BEFORE RUNNING:
* // ---------------
* // 1. If not already done, enable the Stackdriver Trace API
* // and check the quota for your project at
* // https://console.developers.google.com/apis/api/cloudtrace
* // 2. This sample uses Application Default Credentials for authentication.
* // If not already done, install the gcloud CLI from
* // https://cloud.google.com/sdk and run
* // `gcloud beta auth application-default login`.
* // For more information, see
* //
* https://developers.google.com/identity/protocols/application-default-credentials
* // 3. Install the Node.js client library by running
* // `npm install googleapis --save`
*
* var google = require('googleapis');
* var cloudTrace = google.cloudtrace('v1');
*
* authorize(function(authClient) {
* var request = {
* // ID of the Cloud project where the trace data is stored.
* projectId: 'my-project-id', // TODO: Update placeholder value.
*
* resource: {
* // TODO: Add desired properties to the request body. Only these
* properties
* // will be changed.
* },
*
* auth: authClient,
* };
*
* cloudTrace.projects.patchTraces(request, function(err) {
* if (err) {
* console.error(err);
* return;
* }
* });
* });
*
* function authorize(callback) {
* google.auth.getApplicationDefault(function(err, authClient) {
* if (err) {
* console.error('authentication failed: ', err);
* return;
* }
* if (authClient.createScopedRequired &&
* authClient.createScopedRequired()) { var scopes =
* ['https://www.googleapis.com/auth/cloud-platform']; authClient =
* authClient.createScoped(scopes);
* }
* callback(authClient);
* });
* }
* @alias cloudtrace.projects.patchTraces
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.projectId ID of the Cloud project where the trace data is stored.
* @param {().Traces} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
patchTraces(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
patchTraces(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
}
export declare class Resource$Projects$Traces {
root: Cloudtrace;
constructor(root: Cloudtrace);
getRoot(): Cloudtrace;
/**
* cloudtrace.projects.traces.get
* @desc Gets a single trace by its ID.
* @example
* * // BEFORE RUNNING:
* // ---------------
* // 1. If not already done, enable the Stackdriver Trace API
* // and check the quota for your project at
* // https://console.developers.google.com/apis/api/cloudtrace
* // 2. This sample uses Application Default Credentials for authentication.
* // If not already done, install the gcloud CLI from
* // https://cloud.google.com/sdk and run
* // `gcloud beta auth application-default login`.
* // For more information, see
* //
* https://developers.google.com/identity/protocols/application-default-credentials
* // 3. Install the Node.js client library by running
* // `npm install googleapis --save`
*
* var google = require('googleapis');
* var cloudTrace = google.cloudtrace('v1');
*
* authorize(function(authClient) {
* var request = {
* // ID of the Cloud project where the trace data is stored.
* projectId: 'my-project-id', // TODO: Update placeholder value.
*
* // ID of the trace to return.
* traceId: 'my-trace-id', // TODO: Update placeholder value.
*
* auth: authClient,
* };
*
* cloudTrace.projects.traces.get(request, function(err, response) {
* if (err) {
* console.error(err);
* return;
* }
*
* // TODO: Change code below to process the `response` object:
* console.log(JSON.stringify(response, null, 2));
* });
* });
*
* function authorize(callback) {
* google.auth.getApplicationDefault(function(err, authClient) {
* if (err) {
* console.error('authentication failed: ', err);
* return;
* }
* if (authClient.createScopedRequired &&
* authClient.createScopedRequired()) { var scopes =
* ['https://www.googleapis.com/auth/cloud-platform']; authClient =
* authClient.createScoped(scopes);
* }
* callback(authClient);
* });
* }
* @alias cloudtrace.projects.traces.get
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.projectId ID of the Cloud project where the trace data is stored.
* @param {string} params.traceId ID of the trace to return.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
get(params?: any, options?: MethodOptions): AxiosPromise<Schema$Trace>;
get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Trace>, callback?: BodyResponseCallback<Schema$Trace>): void;
/**
* cloudtrace.projects.traces.list
* @desc Returns of a list of traces that match the specified filter
* conditions.
* @example
* * // BEFORE RUNNING:
* // ---------------
* // 1. If not already done, enable the Stackdriver Trace API
* // and check the quota for your project at
* // https://console.developers.google.com/apis/api/cloudtrace
* // 2. This sample uses Application Default Credentials for authentication.
* // If not already done, install the gcloud CLI from
* // https://cloud.google.com/sdk and run
* // `gcloud beta auth application-default login`.
* // For more information, see
* //
* https://developers.google.com/identity/protocols/application-default-credentials
* // 3. Install the Node.js client library by running
* // `npm install googleapis --save`
*
* var google = require('googleapis');
* var cloudTrace = google.cloudtrace('v1');
*
* authorize(function(authClient) {
* var request = {
* // ID of the Cloud project where the trace data is stored.
* projectId: 'my-project-id', // TODO: Update placeholder value.
*
* auth: authClient,
* };
*
* var handlePage = function(err, response) {
* if (err) {
* console.error(err);
* return;
* }
*
* var tracesPage = response['traces'];
* if (!tracesPage) {
* return;
* }
* for (var i = 0; i < tracesPage.length; i++) {
* // TODO: Change code below to process each resource in `tracesPage`:
* console.log(JSON.stringify(tracesPage[i], null, 2));
* }
*
* if (response.nextPageToken) {
* request.pageToken = response.nextPageToken;
* cloudTrace.projects.traces.list(request, handlePage);
* }
* };
*
* cloudTrace.projects.traces.list(request, handlePage);
* });
*
* function authorize(callback) {
* google.auth.getApplicationDefault(function(err, authClient) {
* if (err) {
* console.error('authentication failed: ', err);
* return;
* }
* if (authClient.createScopedRequired &&
* authClient.createScopedRequired()) { var scopes =
* ['https://www.googleapis.com/auth/cloud-platform']; authClient =
* authClient.createScoped(scopes);
* }
* callback(authClient);
* });
* }
* @alias cloudtrace.projects.traces.list
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string=} params.endTime End of the time interval (inclusive) during which the trace data was collected from the application.
* @param {string=} params.filter An optional filter against labels for the request. By default, searches use prefix matching. To specify exact match, prepend a plus symbol (`+`) to the search term. Multiple terms are ANDed. Syntax: * `root:NAME_PREFIX` or `NAME_PREFIX`: Return traces where any root span starts with `NAME_PREFIX`. * `+root:NAME` or `+NAME`: Return traces where any root span's name is exactly `NAME`. * `span:NAME_PREFIX`: Return traces where any span starts with `NAME_PREFIX`. * `+span:NAME`: Return traces where any span's name is exactly `NAME`. * `latency:DURATION`: Return traces whose overall latency is greater or equal to than `DURATION`. Accepted units are nanoseconds (`ns`), milliseconds (`ms`), and seconds (`s`). Default is `ms`. For example, `latency:24ms` returns traces whose overall latency is greater than or equal to 24 milliseconds. * `label:LABEL_KEY`: Return all traces containing the specified label key (exact match, case-sensitive) regardless of the key:value pair's value (including empty values). * `LABEL_KEY:VALUE_PREFIX`: Return all traces containing the specified label key (exact match, case-sensitive) whose value starts with `VALUE_PREFIX`. Both a key and a value must be specified. * `+LABEL_KEY:VALUE`: Return all traces containing a key:value pair exactly matching the specified text. Both a key and a value must be specified. * `method:VALUE`: Equivalent to `/http/method:VALUE`. * `url:VALUE`: Equivalent to `/http/url:VALUE`.
* @param {string=} params.orderBy Field used to sort the returned traces. Optional. Can be one of the following: * `trace_id` * `name` (`name` field of root span in the trace) * `duration` (difference between `end_time` and `start_time` fields of the root span) * `start` (`start_time` field of the root span) Descending order can be specified by appending `desc` to the sort field (for example, `name desc`). Only one sort field is permitted.
* @param {integer=} params.pageSize Maximum number of traces to return. If not specified or <= 0, the implementation selects a reasonable value. The implementation may return fewer traces than the requested page size. Optional.
* @param {string=} params.pageToken Token identifying the page of results to return. If provided, use the value of the `next_page_token` field from a previous request. Optional.
* @param {string} params.projectId ID of the Cloud project where the trace data is stored.
* @param {string=} params.startTime Start of the time interval (inclusive) during which the trace data was collected from the application.
* @param {string=} params.view Type of data returned for traces in the list. Optional. Default is `MINIMAL`.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
list(params?: any, options?: MethodOptions): AxiosPromise<Schema$ListTracesResponse>;
list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ListTracesResponse>, callback?: BodyResponseCallback<Schema$ListTracesResponse>): void;
}