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

"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

109

# span.

110

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

111

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

112

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

113

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

114

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

115

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

116

#

117

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

118

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

119

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

120

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

121

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

122

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

123

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

124

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

125

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

126

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

127

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

128

#

129

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

130

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

131

# shortened string might be less than the size limit.

132

},

133

"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.

138

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

139

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

140

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

141

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

142

# Stackdriver Trace is unable to take advantage of this helpful

143

# information.

144

"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]

145

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

146

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

147

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

148

#

149

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

150

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

Bu Sun Kim

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

[diff] [blame^]

151

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

152

"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]

153

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

154

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

Bu Sun Kim

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

[diff] [blame^]

155

"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]

156

# message types for APIs to use.

157

{

Bu Sun Kim

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

[diff] [blame^]

158

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

Bu Sun Kim

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

[diff] [blame]

159

},

160

],

161

},

Bu Sun Kim

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

[diff] [blame^]

162

"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]

163

#

164

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

165

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

166

#

167

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

168

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

Bu Sun Kim

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

[diff] [blame^]

169

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

170

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

Bu Sun Kim

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

[diff] [blame]

171

# stack traces within a single trace.

172

#

173

# Often multiple spans will have identical stack traces.

174

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

175

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

176

#

177

# Subsequent spans within the same request can refer

178

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

Bu Sun Kim

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

[diff] [blame^]

179

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

180

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

181

# were too many stack frames.

182

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

183

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

Bu Sun Kim

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

[diff] [blame]

184

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

Bu Sun Kim

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

[diff] [blame^]

185

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

186

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

187

"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]

188

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

Bu Sun Kim

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

[diff] [blame^]

189

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

190

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

191

"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]

192

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

193

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

194

#

195

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

196

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

197

# shortened string might be less than the size limit.

Bu Sun Kim

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

[diff] [blame^]

198

},

199

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

200

# contents (up to 128 bytes).

201

"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]

202

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

Bu Sun Kim

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

[diff] [blame^]

203

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

204

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

205

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

206

#

207

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

208

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

209

# shortened string might be less than the size limit.

Bu Sun Kim

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

[diff] [blame]

210

},

211

},

Bu Sun Kim

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

[diff] [blame^]

212

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

213

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

214

"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

215

# bytes).

216

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

217

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

218

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

219

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

220

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

221

#

222

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

223

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

224

# shortened string might be less than the size limit.

225

},

226

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

227

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

228

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

229

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

230

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

231

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

232

#

233

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

234

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

235

# shortened string might be less than the size limit.

236

},

237

"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]

238

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

239

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

Bu Sun Kim

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

[diff] [blame^]

240

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

241

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

242

"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]

243

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

244

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

245

#

246

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

247

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

248

# shortened string might be less than the size limit.

Bu Sun Kim

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

[diff] [blame^]

249

},

250

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

251

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

252

"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]

253

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

Bu Sun Kim

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

[diff] [blame^]

254

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

255

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

256

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

257

#

258

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

259

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

260

# shortened string might be less than the size limit.

Bu Sun Kim

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

[diff] [blame]

261

},

262

},

263

],

Bu Sun Kim

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

[diff] [blame]

264

},

265

},

Bu Sun Kim

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

[diff] [blame^]

266

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

267

# then this field must be empty.

268

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

269

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

270

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

271

"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]

272

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

273

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

Bu Sun Kim

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

[diff] [blame^]

274

"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]

275

# 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^]

276

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

277

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

278

# Stackdriver Trace displays the description in the

279

# Google Cloud Platform Console.

280

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

281

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

282

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

283

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

284

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

285

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

286

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

287

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

288

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

Bu Sun Kim

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

[diff] [blame]

289

#

Bu Sun Kim

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

[diff] [blame^]

290

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

291

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

292

# shortened string might be less than the size limit.

Bu Sun Kim

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

[diff] [blame]

293

},

Bu Sun Kim

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

[diff] [blame^]

294

"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]

295

# events per span.

296

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

297

# details of a message sent/received between Spans.

Bu Sun Kim

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

[diff] [blame^]

298

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

299

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

300

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

301

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

302

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

Bu Sun Kim

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

[diff] [blame]

303

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

Bu Sun Kim

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

[diff] [blame^]

304

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

305

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

Bu Sun Kim

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

[diff] [blame]

306

# received.

Bu Sun Kim

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

[diff] [blame^]

307

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

Bu Sun Kim

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

[diff] [blame]

308

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

309

# a Span.

Bu Sun Kim

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

[diff] [blame^]

310

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

Bu Sun Kim

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

[diff] [blame]

311

# be the same size as uncompressed.

Bu Sun Kim

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

[diff] [blame^]

312

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

Bu Sun Kim

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

[diff] [blame]

313

},

Bu Sun Kim

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

[diff] [blame^]

314

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

315

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

316

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

317

# the description is 256 bytes.

318

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

319

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

320

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

321

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

322

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

323

#

324

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

325

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

326

# shortened string might be less than the size limit.

327

},

328

"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]

329

# per Annotation.

Bu Sun Kim

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

[diff] [blame^]

330

"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]

331

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

332

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

Bu Sun Kim

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

[diff] [blame^]

333

"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]

334

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

335

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

336

#

Bu Sun Kim

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

[diff] [blame^]

337

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

338

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

339

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

340

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

341

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

342

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

343

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

344

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

345

"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]

346

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

347

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

348

#

349

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

350

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

351

# shortened string might be less than the size limit.

Bu Sun Kim

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

[diff] [blame]

352

},

Bu Sun Kim

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

[diff] [blame^]

353

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

Bu Sun Kim

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

[diff] [blame]

354

},

355

},

356

},

Bu Sun Kim

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

[diff] [blame]

357

},

Bu Sun Kim

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

[diff] [blame]

358

},

359

],

Bu Sun Kim

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

[diff] [blame]

360

},

Bu Sun Kim

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

[diff] [blame^]

361

"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.

362

# in the same or different trace.

363

"link": [ # A collection of links.

364

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

365

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

366

# where a single batch handler processes multiple requests from different

367

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

368

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

369

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

370

"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

371

# link.

372

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

373

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

374

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

375

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

376

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

377

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

378

#

379

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

380

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

381

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

382

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

383

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

384

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

385

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

386

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

387

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

388

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

389

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

390

#

391

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

392

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

393

# shortened string might be less than the size limit.

394

},

395

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

},

},

},

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

400

},

401

],

402

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

403

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

404

},

Bu Sun Kim