Blame - docs/dyn/cloudtrace_v2.projects.traces.html - platform/external/python/google-api-python-client

2019-06-14 16:50:42 -0700

[diff] [blame]

76

<h2>Instance Methods</h2>

77

78

<code><a href="cloudtrace_v2.projects.traces.spans.html">spans()</a></code>

79

</p>

80

<p class="firstline">Returns the spans Resource.</p>

81

82

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

83

<code><a href="#batchWrite">batchWrite(name, body=None, x__xgafv=None)</a></code></p>

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

84

<p class="firstline">Sends new spans to new or existing traces. You cannot update</p>

85

<h3>Method Details</h3>

86

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

87

<code class="details" id="batchWrite">batchWrite(name, body=None, x__xgafv=None)</code>

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

88

<pre>Sends new spans to new or existing traces. You cannot update

89

existing spans.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

90

In this case, writing traces is not considered an active developer

91

method since traces are machine generated.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

92

93

Args:

94

name: string, Required. The name of the project where the spans belong. The format is

95

`projects/[PROJECT_ID]`. (required)

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

96

body: object, The request body.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

97

The object takes the form of:

98

99

{ # The request message for the `BatchWriteSpans` method.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

100

"spans": [ # Required. A list of new spans. The span names must not match existing

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

101

# spans, or the results are undefined.

102

{ # A span represents a single operation within a trace. Spans can be

103

# nested to form a trace tree. Often, a trace contains a root span

104

# that describes the end-to-end latency, and one or more subspans for

105

# its sub-operations. A trace can also contain multiple root spans,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

106

# or none at all. Spans do not need to be contiguous&mdash;there may be

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

107

# gaps or overlaps between spans in a trace.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

108

"childSpanCount": 42, # Optional. The number of child spans that were generated while this span

109

# was active. If set, allows implementation to detect missing child spans.

110

"sameProcessAsParentSpan": True or False, # Optional. Set this parameter to indicate whether this span is in

111

# the same process as its parent. If you do not set this parameter,

112

# Stackdriver Trace is unable to take advantage of this helpful

113

# information.

114

"status": { # The `Status` type defines a logical error model that is suitable for # Optional. The final status for this span.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

115

# different programming environments, including REST APIs and RPC APIs. It is

116

# used by [gRPC](https://github.com/grpc). Each `Status` message contains

117

# three pieces of data: error code, error message, and error details.

118

#

119

# You can find out more about this error model and how to work with it in the

120

# [API Design Guide](https://cloud.google.com/apis/design/errors).

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

121

"message": "A String", # A developer-facing error message, which should be in English. Any

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

122

# user-facing error message should be localized and sent in the

123

# google.rpc.Status.details field, or localized by the client.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

124

"details": [ # A list of messages that carry the error details. There is a common set of

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

125

# message types for APIs to use.

126

{

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

127

"a_key": "", # Properties of the object. Contains field @type with type URL.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

128

},

129

],

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

130

"code": 42, # The status code, which should be an enum value of google.rpc.Code.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

131

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

132

"name": "A String", # The resource name of the span in the following format:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

133

#

134

# projects/[PROJECT_ID]/traces/[TRACE_ID]/spans/SPAN_ID is a unique identifier for a trace within a project;

135

# it is a 32-character hexadecimal encoding of a 16-byte array.

136

#

137

# [SPAN_ID] is a unique identifier for a span within a trace; it

138

# is a 16-character hexadecimal encoding of an 8-byte array.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

139

"stackTrace": { # A call stack appearing in a trace. # Stack trace captured at the start of the span.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

140

"stackFrames": { # A collection of stack frames, which can be truncated. # Stack frames in this stack trace. A maximum of 128 frames are allowed.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

141

"frame": [ # Stack frames in this call stack.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

142

{ # Represents a single stack frame in a stack trace.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

143

"lineNumber": "A String", # The line number in `file_name` where the function call appears.

144

"loadModule": { # Binary module. # The binary module from where the code was loaded.

145

"module": { # Represents a string that might be shortened to a specified length. # For example: main binary, kernel modules, and dynamic libraries

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

146

# such as libc.so, sharedlib.so (up to 256 bytes).

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

147

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

148

# value is 0, then the string was not shortened.

149

"value": "A String", # The shortened string. For example, if the original string is 500

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

150

# bytes long and the limit of the string is 128 bytes, then

151

# `value` contains the first 128 bytes of the 500-byte string.

152

#

153

# Truncation always happens on a UTF8 character boundary. If there

154

# are multi-byte characters in the string, then the length of the

155

# shortened string might be less than the size limit.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

156

},

157

"buildId": { # Represents a string that might be shortened to a specified length. # A unique identifier for the module, usually a hash of its

158

# contents (up to 128 bytes).

159

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

160

# value is 0, then the string was not shortened.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

161

"value": "A String", # The shortened string. For example, if the original string is 500

162

# bytes long and the limit of the string is 128 bytes, then

163

# `value` contains the first 128 bytes of the 500-byte string.

164

#

165

# Truncation always happens on a UTF8 character boundary. If there

166

# are multi-byte characters in the string, then the length of the

167

# shortened string might be less than the size limit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

168

},

169

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

170

"columnNumber": "A String", # The column number where the function call appears, if available.

171

# This is important in JavaScript because of its anonymous functions.

172

"fileName": { # Represents a string that might be shortened to a specified length. # The name of the source file where the function call appears (up to 256

173

# bytes).

174

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

175

# value is 0, then the string was not shortened.

176

"value": "A String", # The shortened string. For example, if the original string is 500

177

# bytes long and the limit of the string is 128 bytes, then

178

# `value` contains the first 128 bytes of the 500-byte string.

179

#

180

# Truncation always happens on a UTF8 character boundary. If there

181

# are multi-byte characters in the string, then the length of the

182

# shortened string might be less than the size limit.

183

},

184

"sourceVersion": { # Represents a string that might be shortened to a specified length. # The version of the deployed source code (up to 128 bytes).

185

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

186

# value is 0, then the string was not shortened.

187

"value": "A String", # The shortened string. For example, if the original string is 500

188

# bytes long and the limit of the string is 128 bytes, then

189

# `value` contains the first 128 bytes of the 500-byte string.

190

#

191

# Truncation always happens on a UTF8 character boundary. If there

192

# are multi-byte characters in the string, then the length of the

193

# shortened string might be less than the size limit.

194

},

195

"originalFunctionName": { # Represents a string that might be shortened to a specified length. # An un-mangled function name, if `function_name` is

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

196

# [mangled](http://www.avabodh.com/cxxin/namemangling.html). The name can

197

# be fully-qualified (up to 1024 bytes).

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

198

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

199

# value is 0, then the string was not shortened.

200

"value": "A String", # The shortened string. For example, if the original string is 500

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

201

# bytes long and the limit of the string is 128 bytes, then

202

# `value` contains the first 128 bytes of the 500-byte string.

203

#

204

# Truncation always happens on a UTF8 character boundary. If there

205

# are multi-byte characters in the string, then the length of the

206

# shortened string might be less than the size limit.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

207

},

208

"functionName": { # Represents a string that might be shortened to a specified length. # The fully-qualified name that uniquely identifies the function or

209

# method that is active in this frame (up to 1024 bytes).

210

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

211

# value is 0, then the string was not shortened.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

212

"value": "A String", # The shortened string. For example, if the original string is 500

213

# bytes long and the limit of the string is 128 bytes, then

214

# `value` contains the first 128 bytes of the 500-byte string.

215

#

216

# Truncation always happens on a UTF8 character boundary. If there

217

# are multi-byte characters in the string, then the length of the

218

# shortened string might be less than the size limit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

219

},

220

},

221

],

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

222

"droppedFramesCount": 42, # The number of stack frames that were dropped because there

223

# were too many stack frames.

224

# If this value is 0, then no stack frames were dropped.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

225

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

226

"stackTraceHashId": "A String", # The hash ID is used to conserve network bandwidth for duplicate

227

# stack traces within a single trace.

228

#

229

# Often multiple spans will have identical stack traces.

230

# The first occurrence of a stack trace should contain both the

231

# `stackFrame` content and a value in `stackTraceHashId`.

232

#

233

# Subsequent spans within the same request can refer

234

# to that stack trace by only setting `stackTraceHashId`.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

235

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

236

"parentSpanId": "A String", # The [SPAN_ID] of this span's parent span. If this is a root span,

237

# then this field must be empty.

238

"endTime": "A String", # Required. The end time of the span. On the client side, this is the time kept by

239

# the local machine where the span execution ends. On the server side, this

240

# is the time when the server application handler stops running.

241

"spanKind": "A String", # Distinguishes between spans generated in a particular context. For example,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

242

# two spans with the same name may be distinguished using `CLIENT` (caller)

243

# and `SERVER` (callee) to identify an RPC call.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

244

"startTime": "A String", # Required. The start time of the span. On the client side, this is the time kept by

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

245

# the local machine where the span execution starts. On the server side, this

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

246

# is the time when the server's application handler starts running.

247

"displayName": { # Represents a string that might be shortened to a specified length. # Required. A description of the span's operation (up to 128 bytes).

248

# Stackdriver Trace displays the description in the

249

# Google Cloud Platform Console.

250

# For example, the display name can be a qualified method name or a file name

251

# and a line number where the operation is called. A best practice is to use

252

# the same display name within an application and at the same call point.

253

# This makes it easier to correlate spans in different traces.

254

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

255

# value is 0, then the string was not shortened.

256

"value": "A String", # The shortened string. For example, if the original string is 500

257

# bytes long and the limit of the string is 128 bytes, then

258

# `value` contains the first 128 bytes of the 500-byte string.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

259

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

260

# Truncation always happens on a UTF8 character boundary. If there

261

# are multi-byte characters in the string, then the length of the

262

# shortened string might be less than the size limit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

263

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

264

"timeEvents": { # A collection of `TimeEvent`s. A `TimeEvent` is a time-stamped annotation # A set of time events. You can have up to 32 annotations and 128 message

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

265

# events per span.

266

# on the span, consisting of either user-supplied key:value pairs, or

267

# details of a message sent/received between Spans.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

268

"droppedMessageEventsCount": 42, # The number of dropped message events in all the included time events.

269

# If the value is 0, then no message events were dropped.

270

"timeEvent": [ # A collection of `TimeEvent`s.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

271

{ # A time-stamped annotation or message event in the Span.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

272

"annotation": { # Text annotation with a set of attributes. # Text annotation with a set of attributes.

273

"description": { # Represents a string that might be shortened to a specified length. # A user-supplied message describing the event. The maximum length for

274

# the description is 256 bytes.

275

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

276

# value is 0, then the string was not shortened.

277

"value": "A String", # The shortened string. For example, if the original string is 500

278

# bytes long and the limit of the string is 128 bytes, then

279

# `value` contains the first 128 bytes of the 500-byte string.

280

#

281

# Truncation always happens on a UTF8 character boundary. If there

282

# are multi-byte characters in the string, then the length of the

283

# shortened string might be less than the size limit.

284

},

285

"attributes": { # A set of attributes, each in the format `[KEY]:[VALUE]`. # A set of attributes on the annotation. You can have up to 4 attributes

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

286

# per Annotation.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

287

"droppedAttributesCount": 42, # The number of attributes that were discarded. Attributes can be discarded

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

288

# because their keys are too long or because there are too many attributes.

289

# If this value is 0 then all attributes are valid.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

290

"attributeMap": { # The set of attributes. Each attribute's key can be up to 128 bytes

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

291

# long. The value can be a string up to 256 bytes, a signed 64-bit integer,

292

# or the Boolean values `true` and `false`. For example:

293

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

294

# "/instance_id": { "string_value": { "value": "my-instance" } }

295

# "/http/request_bytes": { "int_value": 300 }

296

# "abc.com/myattribute": { "bool_value": false }

297

"a_key": { # The allowed types for [VALUE] in a `[KEY]:[VALUE]` attribute.

298

"intValue": "A String", # A 64-bit signed integer.

299

"stringValue": { # Represents a string that might be shortened to a specified length. # A string up to 256 bytes long.

300

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

301

# value is 0, then the string was not shortened.

302

"value": "A String", # The shortened string. For example, if the original string is 500

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

303

# bytes long and the limit of the string is 128 bytes, then

304

# `value` contains the first 128 bytes of the 500-byte string.

305

#

306

# Truncation always happens on a UTF8 character boundary. If there

307

# are multi-byte characters in the string, then the length of the

308

# shortened string might be less than the size limit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

309

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

310

"boolValue": True or False, # A Boolean value represented by `true` or `false`.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

311

},

312

},

313

},

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

314

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

315

"messageEvent": { # An event describing a message sent/received between Spans. # An event describing a message sent/received between Spans.

316

"id": "A String", # An identifier for the MessageEvent's message that can be used to match

317

# SENT and RECEIVED MessageEvents. It is recommended to be unique within

318

# a Span.

319

"compressedSizeBytes": "A String", # The number of compressed bytes sent or received. If missing assumed to

320

# be the same size as uncompressed.

321

"uncompressedSizeBytes": "A String", # The number of uncompressed bytes sent or received.

322

"type": "A String", # Type of MessageEvent. Indicates whether the message was sent or

323

# received.

324

},

325

"time": "A String", # The timestamp indicating the time the event occurred.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

326

},

327

],

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

328

"droppedAnnotationsCount": 42, # The number of dropped annotations in all the included time events.

329

# If the value is 0, then no annotations were dropped.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

330

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

331

"links": { # A collection of links, which are references from this span to a span # Links associated with the span. You can have up to 128 links per Span.

332

# in the same or different trace.

333

"link": [ # A collection of links.

334

{ # A pointer from the current span to another span in the same trace or in a

335

# different trace. For example, this can be used in batching operations,

336

# where a single batch handler processes multiple requests from different

337

# traces or when the handler receives a request from a different project.

338

"type": "A String", # The relationship of the current span relative to the linked span.

339

"traceId": "A String", # The [TRACE_ID] for a trace within a project.

340

"attributes": { # A set of attributes, each in the format `[KEY]:[VALUE]`. # A set of attributes on the link. You have have up to 32 attributes per

341

# link.

342

"droppedAttributesCount": 42, # The number of attributes that were discarded. Attributes can be discarded

343

# because their keys are too long or because there are too many attributes.

344

# If this value is 0 then all attributes are valid.

345

"attributeMap": { # The set of attributes. Each attribute's key can be up to 128 bytes

346

# long. The value can be a string up to 256 bytes, a signed 64-bit integer,

347

# or the Boolean values `true` and `false`. For example:

348

#

349

# "/instance_id": { "string_value": { "value": "my-instance" } }

350

# "/http/request_bytes": { "int_value": 300 }

351

# "abc.com/myattribute": { "bool_value": false }

352

"a_key": { # The allowed types for [VALUE] in a `[KEY]:[VALUE]` attribute.

353

"intValue": "A String", # A 64-bit signed integer.

354

"stringValue": { # Represents a string that might be shortened to a specified length. # A string up to 256 bytes long.

355

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

356

# value is 0, then the string was not shortened.

357

"value": "A String", # The shortened string. For example, if the original string is 500

358

# bytes long and the limit of the string is 128 bytes, then

359

# `value` contains the first 128 bytes of the 500-byte string.

360

#

361

# Truncation always happens on a UTF8 character boundary. If there

362

# are multi-byte characters in the string, then the length of the

363

# shortened string might be less than the size limit.

364

},

365

"boolValue": True or False, # A Boolean value represented by `true` or `false`.

},

},

},

"spanId": "A String", # The [SPAN_ID] for a span within a trace.

370

},

371

],

372

"droppedLinksCount": 42, # The number of dropped links after the maximum size was enforced. If

373

# this value is 0, then no links were dropped.

374

},

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

375

"attributes": { # A set of attributes, each in the format `[KEY]:[VALUE]`. # A set of attributes on the span. You can have up to 32 attributes per

376

# span.

377

"droppedAttributesCount": 42, # The number of attributes that were discarded. Attributes can be discarded

378

# because their keys are too long or because there are too many attributes.

379

# If this value is 0 then all attributes are valid.

380

"attributeMap": { # The set of attributes. Each attribute's key can be up to 128 bytes

381

# long. The value can be a string up to 256 bytes, a signed 64-bit integer,

382

# or the Boolean values `true` and `false`. For example:

383

#

384

# "/instance_id": { "string_value": { "value": "my-instance" } }

385

# "/http/request_bytes": { "int_value": 300 }

386

# "abc.com/myattribute": { "bool_value": false }

387

"a_key": { # The allowed types for [VALUE] in a `[KEY]:[VALUE]` attribute.

388

"intValue": "A String", # A 64-bit signed integer.

389

"stringValue": { # Represents a string that might be shortened to a specified length. # A string up to 256 bytes long.

390

"truncatedByteCount": 42, # The number of bytes removed from the original string. If this

391

# value is 0, then the string was not shortened.

392

"value": "A String", # The shortened string. For example, if the original string is 500

393

# bytes long and the limit of the string is 128 bytes, then

394

# `value` contains the first 128 bytes of the 500-byte string.

395

#

396

# Truncation always happens on a UTF8 character boundary. If there

397

# are multi-byte characters in the string, then the length of the

398

# shortened string might be less than the size limit.

399

},

400

"boolValue": True or False, # A Boolean value represented by `true` or `false`.

},

},

},

"spanId": "A String", # Required. The [SPAN_ID] portion of the span's resource name.

Bu Sun Kim