// Type definitions for non-npm package Google Stackdriver Trace API v2 2.0 // Project: https://cloud.google.com/trace // Definitions by: Bolisov Alexey // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 // IMPORTANT // This file was generated by https://github.com/Bolisov/google-api-typings-generator. Please do not edit it manually. // In case of any problems please post issue to https://github.com/Bolisov/google-api-typings-generator // Generated from: https://cloudtrace.googleapis.com/$discovery/rest?version=v2 /// declare namespace gapi.client { /** Load Stackdriver Trace API v2 */ function load(name: "cloudtrace", version: "v2"): PromiseLike; function load(name: "cloudtrace", version: "v2", callback: () => any): void; const projects: cloudtrace.ProjectsResource; namespace cloudtrace { interface Annotation { /** * A set of attributes on the annotation. There is a limit of 4 attributes * per Annotation. */ attributes?: Attributes; /** * A user-supplied message describing the event. The maximum length for * the description is 256 bytes. */ description?: TruncatableString; } interface AttributeValue { /** A Boolean value represented by `true` or `false`. */ boolValue?: boolean; /** A 64-bit signed integer. */ intValue?: string; /** A string up to 256 bytes long. */ stringValue?: TruncatableString; } interface Attributes { /** * The set of attributes. Each attribute's key can be up to 128 bytes * long. The value can be a string up to 256 bytes, an integer, or the * Boolean values `true` and `false`. For example: * * "/instance_id": "my-instance" * "/http/user_agent": "" * "/http/request_bytes": 300 * "abc.com/myattribute": true */ attributeMap?: Record; /** * The number of attributes that were discarded. Attributes can be discarded * because their keys are too long or because there are too many attributes. * If this value is 0 then all attributes are valid. */ droppedAttributesCount?: number; } interface BatchWriteSpansRequest { /** A collection of spans. */ spans?: Span[]; } interface Link { /** * A set of attributes on the link. There is a limit of 32 attributes per * link. */ attributes?: Attributes; /** `SPAN_ID` identifies a span within a trace. */ spanId?: string; /** `TRACE_ID` identifies a trace within a project. */ traceId?: string; /** The relationship of the current span relative to the linked span. */ type?: string; } interface Links { /** * The number of dropped links after the maximum size was enforced. If * this value is 0, then no links were dropped. */ droppedLinksCount?: number; /** A collection of links. */ link?: Link[]; } interface Module { /** * A unique identifier for the module, usually a hash of its * contents (up to 128 bytes). */ buildId?: TruncatableString; /** * For example: main binary, kernel modules, and dynamic libraries * such as libc.so, sharedlib.so (up to 256 bytes). */ module?: TruncatableString; } interface NetworkEvent { /** The number of compressed bytes sent or received. */ compressedMessageSize?: string; /** An identifier for the message, which must be unique in this span. */ messageId?: string; /** * For sent messages, this is the time at which the first bit was sent. * For received messages, this is the time at which the last bit was * received. */ time?: string; /** * Type of NetworkEvent. Indicates whether the RPC message was sent or * received. */ type?: string; /** The number of uncompressed bytes sent or received. */ uncompressedMessageSize?: string; } interface Span { /** * A set of attributes on the span. There is a limit of 32 attributes per * span. */ attributes?: Attributes; /** * An optional number of child spans that were generated while this span * was active. If set, allows implementation to detect missing child spans. */ childSpanCount?: number; /** * A description of the span's operation (up to 128 bytes). * Stackdriver Trace displays the description in the * {% dynamic print site_values.console_name %}. * For example, the display name can be a qualified method name or a file name * and a line number where the operation is called. A best practice is to use * the same display name within an application and at the same call point. * This makes it easier to correlate spans in different traces. */ displayName?: TruncatableString; /** * The end time of the span. On the client side, this is the time kept by * the local machine where the span execution ends. On the server side, this * is the time when the server application handler stops running. */ endTime?: string; /** A maximum of 128 links are allowed per Span. */ links?: Links; /** * The resource name of the span in the following format: * * projects/[PROJECT_ID]/traces/[TRACE_ID]/spans/SPAN_ID is a unique identifier for a trace within a project. * [SPAN_ID] is a unique identifier for a span within a trace, * assigned when the span is created. */ name?: string; /** * The [SPAN_ID] of this span's parent span. If this is a root span, * then this field must be empty. */ parentSpanId?: string; /** * A highly recommended but not required flag that identifies when a trace * crosses a process boundary. True when the parent_span belongs to the * same process as the current span. */ sameProcessAsParentSpan?: boolean; /** The [SPAN_ID] portion of the span's resource name. */ spanId?: string; /** Stack trace captured at the start of the span. */ stackTrace?: StackTrace; /** * The start time of the span. On the client side, this is the time kept by * the local machine where the span execution starts. On the server side, this * is the time when the server's application handler starts running. */ startTime?: string; /** An optional final status for this span. */ status?: Status; /** * The included time events. There can be up to 32 annotations and 128 network * events per span. */ timeEvents?: TimeEvents; } interface StackFrame { /** * The column number where the function call appears, if available. * This is important in JavaScript because of its anonymous functions. */ columnNumber?: string; /** * The name of the source file where the function call appears (up to 256 * bytes). */ fileName?: TruncatableString; /** * The fully-qualified name that uniquely identifies the function or * method that is active in this frame (up to 1024 bytes). */ functionName?: TruncatableString; /** The line number in `file_name` where the function call appears. */ lineNumber?: string; /** The binary module from where the code was loaded. */ loadModule?: Module; /** * An un-mangled function name, if `function_name` is * [mangled](http://www.avabodh.com/cxxin/namemangling.html). The name can * be fully-qualified (up to 1024 bytes). */ originalFunctionName?: TruncatableString; /** The version of the deployed source code (up to 128 bytes). */ sourceVersion?: TruncatableString; } interface StackFrames { /** * The number of stack frames that were dropped because there * were too many stack frames. * If this value is 0, then no stack frames were dropped. */ droppedFramesCount?: number; /** Stack frames in this call stack. */ frame?: StackFrame[]; } interface StackTrace { /** Stack frames in this stack trace. A maximum of 128 frames are allowed. */ stackFrames?: StackFrames; /** * The hash ID is used to conserve network bandwidth for duplicate * stack traces within a single trace. * * Often multiple spans will have identical stack traces. * The first occurrence of a stack trace should contain both the * `stackFrame` content and a value in `stackTraceHashId`. * * Subsequent spans within the same request can refer * to that stack trace by only setting `stackTraceHashId`. */ stackTraceHashId?: string; } interface Status { /** The status code, which should be an enum value of google.rpc.Code. */ code?: number; /** * A list of messages that carry the error details. There is a common set of * message types for APIs to use. */ details?: Array>; /** * A developer-facing error message, which should be in English. Any * user-facing error message should be localized and sent in the * google.rpc.Status.details field, or localized by the client. */ message?: string; } interface TimeEvent { /** Text annotation with a set of attributes. */ annotation?: Annotation; /** An event describing an RPC message sent/received on the network. */ networkEvent?: NetworkEvent; /** The timestamp indicating the time the event occurred. */ time?: string; } interface TimeEvents { /** * The number of dropped annotations in all the included time events. * If the value is 0, then no annotations were dropped. */ droppedAnnotationsCount?: number; /** * The number of dropped network events in all the included time events. * If the value is 0, then no network events were dropped. */ droppedNetworkEventsCount?: number; /** A collection of `TimeEvent`s. */ timeEvent?: TimeEvent[]; } interface TruncatableString { /** * The number of bytes removed from the original string. If this * value is 0, then the string was not shortened. */ truncatedByteCount?: number; /** * The shortened string. For example, if the original string was 500 * bytes long and the limit of the string was 128 bytes, then this * value contains the first 128 bytes of the 500-byte string. Note that * truncation always happens on the character boundary, to ensure that * truncated string is still valid UTF8. In case of multi-byte characters, * size of truncated string can be less than truncation limit. */ value?: string; } interface SpansResource { /** Creates a new Span. */ create(request: { /** V1 error format. */ "$.xgafv"?: string; /** OAuth access token. */ access_token?: string; /** Data format for response. */ alt?: string; /** OAuth bearer token. */ bearer_token?: string; /** JSONP */ callback?: string; /** Selector specifying which fields to include in a partial response. */ fields?: string; /** API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. */ key?: string; /** * The resource name of the span in the following format: * * projects/[PROJECT_ID]/traces/[TRACE_ID]/spans/SPAN_ID is a unique identifier for a trace within a project. * [SPAN_ID] is a unique identifier for a span within a trace, * assigned when the span is created. */ name: string; /** OAuth 2.0 token for the current user. */ oauth_token?: string; /** Pretty-print response. */ pp?: boolean; /** Returns response with indentations and line breaks. */ prettyPrint?: boolean; /** Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. */ quotaUser?: string; /** Legacy upload protocol for media (e.g. "media", "multipart"). */ uploadType?: string; /** Upload protocol for media (e.g. "raw", "multipart"). */ upload_protocol?: string; }): Request; } interface TracesResource { /** * Sends new spans to Stackdriver Trace or updates existing traces. If the * name of a trace that you send matches that of an existing trace, new spans * are added to the existing trace. Attempt to update existing spans results * undefined behavior. If the name does not match, a new trace is created * with given set of spans. */ batchWrite(request: { /** V1 error format. */ "$.xgafv"?: string; /** OAuth access token. */ access_token?: string; /** Data format for response. */ alt?: string; /** OAuth bearer token. */ bearer_token?: string; /** JSONP */ callback?: string; /** Selector specifying which fields to include in a partial response. */ fields?: string; /** API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. */ key?: string; /** * Required. Name of the project where the spans belong. The format is * `projects/PROJECT_ID`. */ name: string; /** OAuth 2.0 token for the current user. */ oauth_token?: string; /** Pretty-print response. */ pp?: boolean; /** Returns response with indentations and line breaks. */ prettyPrint?: boolean; /** Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. */ quotaUser?: string; /** Legacy upload protocol for media (e.g. "media", "multipart"). */ uploadType?: string; /** Upload protocol for media (e.g. "raw", "multipart"). */ upload_protocol?: string; }): Request<{}>; spans: SpansResource; } interface ProjectsResource { traces: TracesResource; } } }