1<html><body>
2<style>
3
4body, h1, h2, h3, div, span, p, pre, a {
5  margin: 0;
6  padding: 0;
7  border: 0;
8  font-weight: inherit;
9  font-style: inherit;
10  font-size: 100%;
11  font-family: inherit;
12  vertical-align: baseline;
13}
14
15body {
16  font-size: 13px;
17  padding: 1em;
18}
19
20h1 {
21  font-size: 26px;
22  margin-bottom: 1em;
23}
24
25h2 {
26  font-size: 24px;
27  margin-bottom: 1em;
28}
29
30h3 {
31  font-size: 20px;
32  margin-bottom: 1em;
33  margin-top: 1em;
34}
35
36pre, code {
37  line-height: 1.5;
38  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
39}
40
41pre {
42  margin-top: 0.5em;
43}
44
45h1, h2, h3, p {
46  font-family: Arial, sans serif;
47}
48
49h1, h2, h3 {
50  border-bottom: solid #CCC 1px;
51}
52
53.toc_element {
54  margin-top: 0.5em;
55}
56
57.firstline {
58  margin-left: 2 em;
59}
60
61.method  {
62  margin-top: 1em;
63  border: solid 1px #CCC;
64  padding: 1em;
65  background: #EEE;
66}
67
68.details {
69  font-weight: bold;
70  font-size: 14px;
71}
72
73</style>
74
75<h1><a href="toolresults_v1beta3.html">Cloud Tool Results API</a> . <a href="toolresults_v1beta3.projects.html">projects</a> . <a href="toolresults_v1beta3.projects.histories.html">histories</a> . <a href="toolresults_v1beta3.projects.histories.executions.html">executions</a> . <a href="toolresults_v1beta3.projects.histories.executions.steps.html">steps</a> . <a href="toolresults_v1beta3.projects.histories.executions.steps.perfSampleSeries.html">perfSampleSeries</a> . <a href="toolresults_v1beta3.projects.histories.executions.steps.perfSampleSeries.samples.html">samples</a></h1>
76<h2>Instance Methods</h2>
77<p class="toc_element">
78  <code><a href="#batchCreate">batchCreate(projectId, historyId, executionId, stepId, sampleSeriesId, body)</a></code></p>
79<p class="firstline">Creates a batch of PerfSamples - a client can submit multiple batches of Perf Samples through repeated calls to this method in order to split up a large request payload - duplicates and existing timestamp entries will be ignored. - the batch operation may partially succeed - the set of elements successfully inserted is returned in the response (omits items which already existed in the database).</p>
80<p class="toc_element">
81  <code><a href="#list">list(projectId, historyId, executionId, stepId, sampleSeriesId, pageSize=None, pageToken=None)</a></code></p>
82<p class="firstline">Lists the Performance Samples of a given Sample Series - The list results are sorted by timestamps ascending - The default page size is 500 samples; and maximum size allowed 5000 - The response token indicates the last returned PerfSample timestamp - When the results size exceeds the page size, submit a subsequent request including the page token to return the rest of the samples up to the page limit</p>
83<p class="toc_element">
84  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
85<p class="firstline">Retrieves the next page of results.</p>
86<h3>Method Details</h3>
87<div class="method">
88    <code class="details" id="batchCreate">batchCreate(projectId, historyId, executionId, stepId, sampleSeriesId, body)</code>
89  <pre>Creates a batch of PerfSamples - a client can submit multiple batches of Perf Samples through repeated calls to this method in order to split up a large request payload - duplicates and existing timestamp entries will be ignored. - the batch operation may partially succeed - the set of elements successfully inserted is returned in the response (omits items which already existed in the database).
90
91May return any of the following canonical error codes: - NOT_FOUND - The containing PerfSampleSeries does not exist
92
93Args:
94  projectId: string, The cloud project (required)
95  historyId: string, A tool results history ID. (required)
96  executionId: string, A tool results execution ID. (required)
97  stepId: string, A tool results step ID. (required)
98  sampleSeriesId: string, A sample series id (required)
99  body: object, The request body. (required)
100    The object takes the form of:
101
102{ # The request must provide up to a maximum of 5000 samples to be created; a larger sample size will cause an INVALID_ARGUMENT error
103    "perfSamples": [ # The set of PerfSamples to create should not include existing timestamps
104      { # Resource representing a single performance measure or data point
105        "sampleTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # Timestamp of collection
106            #
107            # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
108            #
109            # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
110            #
111            # # Examples
112            #
113            # Example 1: Compute Timestamp from POSIX `time()`.
114            #
115            # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
116            #
117            # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
118            #
119            # struct timeval tv; gettimeofday(&tv, NULL);
120            #
121            # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
122            #
123            # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
124            #
125            # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
126            #
127            # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
128            #
129            # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
130            #
131            # long millis = System.currentTimeMillis();
132            #
133            # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
134            #
135            #
136            #
137            # Example 5: Compute Timestamp from current time in Python.
138            #
139            # timestamp = Timestamp() timestamp.GetCurrentTime()
140            #
141            # # JSON Mapping
142            #
143            # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
144            #
145            # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
146            #
147            # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
148          "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
149          "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
150        },
151        "value": 3.14, # Value observed
152      },
153    ],
154  }
155
156
157Returns:
158  An object of the form:
159
160    {
161    "perfSamples": [
162      { # Resource representing a single performance measure or data point
163        "sampleTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # Timestamp of collection
164            #
165            # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
166            #
167            # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
168            #
169            # # Examples
170            #
171            # Example 1: Compute Timestamp from POSIX `time()`.
172            #
173            # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
174            #
175            # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
176            #
177            # struct timeval tv; gettimeofday(&tv, NULL);
178            #
179            # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
180            #
181            # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
182            #
183            # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
184            #
185            # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
186            #
187            # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
188            #
189            # long millis = System.currentTimeMillis();
190            #
191            # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
192            #
193            #
194            #
195            # Example 5: Compute Timestamp from current time in Python.
196            #
197            # timestamp = Timestamp() timestamp.GetCurrentTime()
198            #
199            # # JSON Mapping
200            #
201            # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
202            #
203            # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
204            #
205            # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
206          "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
207          "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
208        },
209        "value": 3.14, # Value observed
210      },
211    ],
212  }</pre>
213</div>
214
215<div class="method">
216    <code class="details" id="list">list(projectId, historyId, executionId, stepId, sampleSeriesId, pageSize=None, pageToken=None)</code>
217  <pre>Lists the Performance Samples of a given Sample Series - The list results are sorted by timestamps ascending - The default page size is 500 samples; and maximum size allowed 5000 - The response token indicates the last returned PerfSample timestamp - When the results size exceeds the page size, submit a subsequent request including the page token to return the rest of the samples up to the page limit
218
219May return any of the following canonical error codes: - OUT_OF_RANGE - The specified request page_token is out of valid range - NOT_FOUND - The containing PerfSampleSeries does not exist
220
221Args:
222  projectId: string, The cloud project (required)
223  historyId: string, A tool results history ID. (required)
224  executionId: string, A tool results execution ID. (required)
225  stepId: string, A tool results step ID. (required)
226  sampleSeriesId: string, A sample series id (required)
227  pageSize: integer, The default page size is 500 samples, and the maximum size is 5000. If the page_size is greater than 5000, the effective page size will be 5000
228  pageToken: string, Optional, the next_page_token returned in the previous response
229
230Returns:
231  An object of the form:
232
233    {
234    "nextPageToken": "A String", # Optional, returned if result size exceeds the page size specified in the request (or the default page size, 500, if unspecified). It indicates the last sample timestamp to be used as page_token in subsequent request
235    "perfSamples": [
236      { # Resource representing a single performance measure or data point
237        "sampleTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # Timestamp of collection
238            #
239            # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
240            #
241            # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
242            #
243            # # Examples
244            #
245            # Example 1: Compute Timestamp from POSIX `time()`.
246            #
247            # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
248            #
249            # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
250            #
251            # struct timeval tv; gettimeofday(&tv, NULL);
252            #
253            # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
254            #
255            # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
256            #
257            # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
258            #
259            # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
260            #
261            # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
262            #
263            # long millis = System.currentTimeMillis();
264            #
265            # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
266            #
267            #
268            #
269            # Example 5: Compute Timestamp from current time in Python.
270            #
271            # timestamp = Timestamp() timestamp.GetCurrentTime()
272            #
273            # # JSON Mapping
274            #
275            # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
276            #
277            # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
278            #
279            # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
280          "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
281          "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
282        },
283        "value": 3.14, # Value observed
284      },
285    ],
286  }</pre>
287</div>
288
289<div class="method">
290    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
291  <pre>Retrieves the next page of results.
292
293Args:
294  previous_request: The request for the previous page. (required)
295  previous_response: The response from the request for the previous page. (required)
296
297Returns:
298  A request object that you can call 'execute()' on to request the next
299  page. Returns None if there are no more items in the collection.
300    </pre>
301</div>
302
303</body></html>