Skip to content

tracing

BufferUsage dataclass

EXPERIMENTAL

Source code in zendriver/cdp/tracing.py 
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
@event_class("Tracing.bufferUsage")
@dataclass
class BufferUsage:
    """
    **EXPERIMENTAL**


    """

    #: A number in range [0..1] that indicates the used size of event buffer as a fraction of its
    #: total size.
    percent_full: typing.Optional[float]
    #: An approximate number of events in the trace log.
    event_count: typing.Optional[float]
    #: A number in range [0..1] that indicates the used size of event buffer as a fraction of its
    #: total size.
    value: typing.Optional[float]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> BufferUsage:
        return cls(
            percent_full=float(json["percentFull"])
            if json.get("percentFull", None) is not None
            else None,
            event_count=float(json["eventCount"])
            if json.get("eventCount", None) is not None
            else None,
            value=float(json["value"]) if json.get("value", None) is not None else None,
        )

event_count: typing.Optional[float] instance-attribute

percent_full: typing.Optional[float] instance-attribute

value: typing.Optional[float] instance-attribute

__init__(percent_full, event_count, value)

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
332
333
334
335
336
337
338
339
340
341
342
@classmethod
def from_json(cls, json: T_JSON_DICT) -> BufferUsage:
    return cls(
        percent_full=float(json["percentFull"])
        if json.get("percentFull", None) is not None
        else None,
        event_count=float(json["eventCount"])
        if json.get("eventCount", None) is not None
        else None,
        value=float(json["value"]) if json.get("value", None) is not None else None,
    )

DataCollected dataclass

EXPERIMENTAL

Contains a bucket of collected trace events. When tracing is stopped collected events will be sent as a sequence of dataCollected events followed by tracingComplete event.

Source code in zendriver/cdp/tracing.py 
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
@event_class("Tracing.dataCollected")
@dataclass
class DataCollected:
    """
    **EXPERIMENTAL**

    Contains a bucket of collected trace events. When tracing is stopped collected events will be
    sent as a sequence of dataCollected events followed by tracingComplete event.
    """

    value: typing.List[dict]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> DataCollected:
        return cls(value=[dict(i) for i in json["value"]])

value: typing.List[dict] instance-attribute

__init__(value)

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
357
358
359
@classmethod
def from_json(cls, json: T_JSON_DICT) -> DataCollected:
    return cls(value=[dict(i) for i in json["value"]])

MemoryDumpConfig

Bases: dict

Configuration for memory dump. Used only when "memory-infra" category is enabled.

Source code in zendriver/cdp/tracing.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class MemoryDumpConfig(dict):
    """
    Configuration for memory dump. Used only when "memory-infra" category is enabled.
    """

    def to_json(self) -> dict:
        return self

    @classmethod
    def from_json(cls, json: dict) -> MemoryDumpConfig:
        return cls(json)

    def __repr__(self):
        return "MemoryDumpConfig({})".format(super().__repr__())

__repr__()

Source code in zendriver/cdp/tracing.py 
29
30
def __repr__(self):
    return "MemoryDumpConfig({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
25
26
27
@classmethod
def from_json(cls, json: dict) -> MemoryDumpConfig:
    return cls(json)

to_json()

Source code in zendriver/cdp/tracing.py 
22
23
def to_json(self) -> dict:
    return self

MemoryDumpLevelOfDetail

Bases: Enum

Details exposed when memory request explicitly declared. Keep consistent with memory_dump_request_args.h and memory_instrumentation.mojom

Source code in zendriver/cdp/tracing.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
class MemoryDumpLevelOfDetail(enum.Enum):
    """
    Details exposed when memory request explicitly declared.
    Keep consistent with memory_dump_request_args.h and
    memory_instrumentation.mojom
    """

    BACKGROUND = "background"
    LIGHT = "light"
    DETAILED = "detailed"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> MemoryDumpLevelOfDetail:
        return cls(json)

BACKGROUND = 'background' class-attribute instance-attribute

DETAILED = 'detailed' class-attribute instance-attribute

LIGHT = 'light' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
165
166
167
@classmethod
def from_json(cls, json: str) -> MemoryDumpLevelOfDetail:
    return cls(json)

to_json()

Source code in zendriver/cdp/tracing.py 
162
163
def to_json(self) -> str:
    return self.value

StreamCompression

Bases: Enum

Compression type to use for traces returned via streams.

Source code in zendriver/cdp/tracing.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
class StreamCompression(enum.Enum):
    """
    Compression type to use for traces returned via streams.
    """

    NONE = "none"
    GZIP = "gzip"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> StreamCompression:
        return cls(json)

GZIP = 'gzip' class-attribute instance-attribute

NONE = 'none' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
146
147
148
@classmethod
def from_json(cls, json: str) -> StreamCompression:
    return cls(json)

to_json()

Source code in zendriver/cdp/tracing.py 
143
144
def to_json(self) -> str:
    return self.value

StreamFormat

Bases: Enum

Data format of a trace. Can be either the legacy JSON format or the protocol buffer format. Note that the JSON format will be deprecated soon.

Source code in zendriver/cdp/tracing.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
class StreamFormat(enum.Enum):
    """
    Data format of a trace. Can be either the legacy JSON format or the
    protocol buffer format. Note that the JSON format will be deprecated soon.
    """

    JSON = "json"
    PROTO = "proto"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> StreamFormat:
        return cls(json)

JSON = 'json' class-attribute instance-attribute

PROTO = 'proto' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
130
131
132
@classmethod
def from_json(cls, json: str) -> StreamFormat:
    return cls(json)

to_json()

Source code in zendriver/cdp/tracing.py 
127
128
def to_json(self) -> str:
    return self.value

TraceConfig dataclass

Source code in zendriver/cdp/tracing.py 
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
@dataclass
class TraceConfig:
    #: Controls how the trace buffer stores data.
    record_mode: typing.Optional[str] = None

    #: Size of the trace buffer in kilobytes. If not specified or zero is passed, a default value
    #: of 200 MB would be used.
    trace_buffer_size_in_kb: typing.Optional[float] = None

    #: Turns on JavaScript stack sampling.
    enable_sampling: typing.Optional[bool] = None

    #: Turns on system tracing.
    enable_systrace: typing.Optional[bool] = None

    #: Turns on argument filter.
    enable_argument_filter: typing.Optional[bool] = None

    #: Included category filters.
    included_categories: typing.Optional[typing.List[str]] = None

    #: Excluded category filters.
    excluded_categories: typing.Optional[typing.List[str]] = None

    #: Configuration to synthesize the delays in tracing.
    synthetic_delays: typing.Optional[typing.List[str]] = None

    #: Configuration for memory dump triggers. Used only when "memory-infra" category is enabled.
    memory_dump_config: typing.Optional[MemoryDumpConfig] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        if self.record_mode is not None:
            json["recordMode"] = self.record_mode
        if self.trace_buffer_size_in_kb is not None:
            json["traceBufferSizeInKb"] = self.trace_buffer_size_in_kb
        if self.enable_sampling is not None:
            json["enableSampling"] = self.enable_sampling
        if self.enable_systrace is not None:
            json["enableSystrace"] = self.enable_systrace
        if self.enable_argument_filter is not None:
            json["enableArgumentFilter"] = self.enable_argument_filter
        if self.included_categories is not None:
            json["includedCategories"] = [i for i in self.included_categories]
        if self.excluded_categories is not None:
            json["excludedCategories"] = [i for i in self.excluded_categories]
        if self.synthetic_delays is not None:
            json["syntheticDelays"] = [i for i in self.synthetic_delays]
        if self.memory_dump_config is not None:
            json["memoryDumpConfig"] = self.memory_dump_config.to_json()
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> TraceConfig:
        return cls(
            record_mode=str(json["recordMode"])
            if json.get("recordMode", None) is not None
            else None,
            trace_buffer_size_in_kb=float(json["traceBufferSizeInKb"])
            if json.get("traceBufferSizeInKb", None) is not None
            else None,
            enable_sampling=bool(json["enableSampling"])
            if json.get("enableSampling", None) is not None
            else None,
            enable_systrace=bool(json["enableSystrace"])
            if json.get("enableSystrace", None) is not None
            else None,
            enable_argument_filter=bool(json["enableArgumentFilter"])
            if json.get("enableArgumentFilter", None) is not None
            else None,
            included_categories=[str(i) for i in json["includedCategories"]]
            if json.get("includedCategories", None) is not None
            else None,
            excluded_categories=[str(i) for i in json["excludedCategories"]]
            if json.get("excludedCategories", None) is not None
            else None,
            synthetic_delays=[str(i) for i in json["syntheticDelays"]]
            if json.get("syntheticDelays", None) is not None
            else None,
            memory_dump_config=MemoryDumpConfig.from_json(json["memoryDumpConfig"])
            if json.get("memoryDumpConfig", None) is not None
            else None,
        )

enable_argument_filter: typing.Optional[bool] = None class-attribute instance-attribute

enable_sampling: typing.Optional[bool] = None class-attribute instance-attribute

enable_systrace: typing.Optional[bool] = None class-attribute instance-attribute

excluded_categories: typing.Optional[typing.List[str]] = None class-attribute instance-attribute

included_categories: typing.Optional[typing.List[str]] = None class-attribute instance-attribute

memory_dump_config: typing.Optional[MemoryDumpConfig] = None class-attribute instance-attribute

record_mode: typing.Optional[str] = None class-attribute instance-attribute

synthetic_delays: typing.Optional[typing.List[str]] = None class-attribute instance-attribute

trace_buffer_size_in_kb: typing.Optional[float] = None class-attribute instance-attribute

__init__(record_mode=None, trace_buffer_size_in_kb=None, enable_sampling=None, enable_systrace=None, enable_argument_filter=None, included_categories=None, excluded_categories=None, synthetic_delays=None, memory_dump_config=None)

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
@classmethod
def from_json(cls, json: T_JSON_DICT) -> TraceConfig:
    return cls(
        record_mode=str(json["recordMode"])
        if json.get("recordMode", None) is not None
        else None,
        trace_buffer_size_in_kb=float(json["traceBufferSizeInKb"])
        if json.get("traceBufferSizeInKb", None) is not None
        else None,
        enable_sampling=bool(json["enableSampling"])
        if json.get("enableSampling", None) is not None
        else None,
        enable_systrace=bool(json["enableSystrace"])
        if json.get("enableSystrace", None) is not None
        else None,
        enable_argument_filter=bool(json["enableArgumentFilter"])
        if json.get("enableArgumentFilter", None) is not None
        else None,
        included_categories=[str(i) for i in json["includedCategories"]]
        if json.get("includedCategories", None) is not None
        else None,
        excluded_categories=[str(i) for i in json["excludedCategories"]]
        if json.get("excludedCategories", None) is not None
        else None,
        synthetic_delays=[str(i) for i in json["syntheticDelays"]]
        if json.get("syntheticDelays", None) is not None
        else None,
        memory_dump_config=MemoryDumpConfig.from_json(json["memoryDumpConfig"])
        if json.get("memoryDumpConfig", None) is not None
        else None,
    )

to_json()

Source code in zendriver/cdp/tracing.py 
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    if self.record_mode is not None:
        json["recordMode"] = self.record_mode
    if self.trace_buffer_size_in_kb is not None:
        json["traceBufferSizeInKb"] = self.trace_buffer_size_in_kb
    if self.enable_sampling is not None:
        json["enableSampling"] = self.enable_sampling
    if self.enable_systrace is not None:
        json["enableSystrace"] = self.enable_systrace
    if self.enable_argument_filter is not None:
        json["enableArgumentFilter"] = self.enable_argument_filter
    if self.included_categories is not None:
        json["includedCategories"] = [i for i in self.included_categories]
    if self.excluded_categories is not None:
        json["excludedCategories"] = [i for i in self.excluded_categories]
    if self.synthetic_delays is not None:
        json["syntheticDelays"] = [i for i in self.synthetic_delays]
    if self.memory_dump_config is not None:
        json["memoryDumpConfig"] = self.memory_dump_config.to_json()
    return json

TracingBackend

Bases: Enum

Backend type to use for tracing. chrome uses the Chrome-integrated tracing service and is supported on all platforms. system is only supported on Chrome OS and uses the Perfetto system tracing service. auto chooses system when the perfettoConfig provided to Tracing.start specifies at least one non-Chrome data source; otherwise uses chrome.

Source code in zendriver/cdp/tracing.py 
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
class TracingBackend(enum.Enum):
    """
    Backend type to use for tracing. ``chrome`` uses the Chrome-integrated
    tracing service and is supported on all platforms. ``system`` is only
    supported on Chrome OS and uses the Perfetto system tracing service.
    ``auto`` chooses ``system`` when the perfettoConfig provided to Tracing.start
    specifies at least one non-Chrome data source; otherwise uses ``chrome``.
    """

    AUTO = "auto"
    CHROME = "chrome"
    SYSTEM = "system"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> TracingBackend:
        return cls(json)

AUTO = 'auto' class-attribute instance-attribute

CHROME = 'chrome' class-attribute instance-attribute

SYSTEM = 'system' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
186
187
188
@classmethod
def from_json(cls, json: str) -> TracingBackend:
    return cls(json)

to_json()

Source code in zendriver/cdp/tracing.py 
183
184
def to_json(self) -> str:
    return self.value

TracingComplete dataclass

Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.

Source code in zendriver/cdp/tracing.py 
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
@event_class("Tracing.tracingComplete")
@dataclass
class TracingComplete:
    """
    Signals that tracing is stopped and there is no trace buffers pending flush, all data were
    delivered via dataCollected events.
    """

    #: Indicates whether some trace data is known to have been lost, e.g. because the trace ring
    #: buffer wrapped around.
    data_loss_occurred: bool
    #: A handle of the stream that holds resulting trace data.
    stream: typing.Optional[io.StreamHandle]
    #: Trace data format of returned stream.
    trace_format: typing.Optional[StreamFormat]
    #: Compression format of returned stream.
    stream_compression: typing.Optional[StreamCompression]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> TracingComplete:
        return cls(
            data_loss_occurred=bool(json["dataLossOccurred"]),
            stream=io.StreamHandle.from_json(json["stream"])
            if json.get("stream", None) is not None
            else None,
            trace_format=StreamFormat.from_json(json["traceFormat"])
            if json.get("traceFormat", None) is not None
            else None,
            stream_compression=StreamCompression.from_json(json["streamCompression"])
            if json.get("streamCompression", None) is not None
            else None,
        )

data_loss_occurred: bool instance-attribute

stream: typing.Optional[io.StreamHandle] instance-attribute

stream_compression: typing.Optional[StreamCompression] instance-attribute

trace_format: typing.Optional[StreamFormat] instance-attribute

__init__(data_loss_occurred, stream, trace_format, stream_compression)

from_json(json) classmethod

Source code in zendriver/cdp/tracing.py 
380
381
382
383
384
385
386
387
388
389
390
391
392
393
@classmethod
def from_json(cls, json: T_JSON_DICT) -> TracingComplete:
    return cls(
        data_loss_occurred=bool(json["dataLossOccurred"]),
        stream=io.StreamHandle.from_json(json["stream"])
        if json.get("stream", None) is not None
        else None,
        trace_format=StreamFormat.from_json(json["traceFormat"])
        if json.get("traceFormat", None) is not None
        else None,
        stream_compression=StreamCompression.from_json(json["streamCompression"])
        if json.get("streamCompression", None) is not None
        else None,
    )

end()

Stop trace events collection.

Source code in zendriver/cdp/tracing.py 
191
192
193
194
195
196
197
198
def end() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Stop trace events collection.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Tracing.end",
    }
    json = yield cmd_dict

get_categories()

Gets supported tracing categories.

EXPERIMENTAL

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, List[str]]

A list of supported tracing categories.
Source code in zendriver/cdp/tracing.py 
201
202
203
204
205
206
207
208
209
210
211
212
213
def get_categories() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[str]]:
    """
    Gets supported tracing categories.

    **EXPERIMENTAL**

    :returns: A list of supported tracing categories.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "Tracing.getCategories",
    }
    json = yield cmd_dict
    return [str(i) for i in json["categories"]]

record_clock_sync_marker(sync_id)

Record a clock sync marker in the trace.

EXPERIMENTAL

Parameters:

Name Type Description Default
sync_id str

The ID of this clock sync marker

 required
Source code in zendriver/cdp/tracing.py 
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
def record_clock_sync_marker(
    sync_id: str,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Record a clock sync marker in the trace.

    **EXPERIMENTAL**

    :param sync_id: The ID of this clock sync marker
    """
    params: T_JSON_DICT = dict()
    params["syncId"] = sync_id
    cmd_dict: T_JSON_DICT = {
        "method": "Tracing.recordClockSyncMarker",
        "params": params,
    }
    json = yield cmd_dict

request_memory_dump(deterministic=None, level_of_detail=None)

Request a global memory dump.

EXPERIMENTAL

Parameters:

Name Type Description Default
deterministic Optional[bool]

(Optional) Enables more deterministic results by forcing garbage collection

 None
level_of_detail Optional[MemoryDumpLevelOfDetail]

(Optional) Specifies level of details in memory dump. Defaults to "detailed".

 None

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Tuple[str, bool]]

A tuple with the following items: 0. dumpGuid - GUID of the resulting global memory dump. 1. success - True iff the global memory dump succeeded.
Source code in zendriver/cdp/tracing.py 
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
def request_memory_dump(
    deterministic: typing.Optional[bool] = None,
    level_of_detail: typing.Optional[MemoryDumpLevelOfDetail] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.Tuple[str, bool]]:
    """
    Request a global memory dump.

    **EXPERIMENTAL**

    :param deterministic: *(Optional)* Enables more deterministic results by forcing garbage collection
    :param level_of_detail: *(Optional)* Specifies level of details in memory dump. Defaults to "detailed".
    :returns: A tuple with the following items:

        0. **dumpGuid** - GUID of the resulting global memory dump.
        1. **success** - True iff the global memory dump succeeded.
    """
    params: T_JSON_DICT = dict()
    if deterministic is not None:
        params["deterministic"] = deterministic
    if level_of_detail is not None:
        params["levelOfDetail"] = level_of_detail.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Tracing.requestMemoryDump",
        "params": params,
    }
    json = yield cmd_dict
    return (str(json["dumpGuid"]), bool(json["success"]))

start(categories=None, options=None, buffer_usage_reporting_interval=None, transfer_mode=None, stream_format=None, stream_compression=None, trace_config=None, perfetto_config=None, tracing_backend=None)

Start trace events collection.

Parameters:

Name Type Description Default
categories Optional[str]

(DEPRECATED) (EXPERIMENTAL) (Optional) Category/tag filter

 None
options Optional[str]

(DEPRECATED) (EXPERIMENTAL) (Optional) Tracing options

 None
buffer_usage_reporting_interval Optional[float]

(EXPERIMENTAL) (Optional) If set, the agent will issue bufferUsage events at this interval, specified in milliseconds

 None
transfer_mode Optional[str]

(Optional) Whether to report trace events as series of dataCollected events or to save trace to a stream (defaults to ```ReportEvents````).

 None
stream_format Optional[StreamFormat]

(Optional) Trace data format to use. This only applies when using ReturnAsStream transfer mode (defaults to json).

 None
stream_compression Optional[StreamCompression]

(EXPERIMENTAL) (Optional) Compression format to use. This only applies when using ReturnAsStream transfer mode (defaults to none)

 None
trace_config Optional[TraceConfig]

(Optional)

 None
perfetto_config Optional[str]

(EXPERIMENTAL) (Optional) Base64-encoded serialized perfetto.protos.TraceConfig protobuf message When specified, the parameters categories, options, traceConfig are ignored. (Encoded as a base64 string when passed over JSON)

 None
tracing_backend Optional[TracingBackend]

(EXPERIMENTAL) (Optional) Backend type (defaults to `auto)

 None
Source code in zendriver/cdp/tracing.py 
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
def start(
    categories: typing.Optional[str] = None,
    options: typing.Optional[str] = None,
    buffer_usage_reporting_interval: typing.Optional[float] = None,
    transfer_mode: typing.Optional[str] = None,
    stream_format: typing.Optional[StreamFormat] = None,
    stream_compression: typing.Optional[StreamCompression] = None,
    trace_config: typing.Optional[TraceConfig] = None,
    perfetto_config: typing.Optional[str] = None,
    tracing_backend: typing.Optional[TracingBackend] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Start trace events collection.

    :param categories: **(DEPRECATED)** **(EXPERIMENTAL)** *(Optional)* Category/tag filter
    :param options: **(DEPRECATED)** **(EXPERIMENTAL)** *(Optional)* Tracing options
    :param buffer_usage_reporting_interval: **(EXPERIMENTAL)** *(Optional)* If set, the agent will issue bufferUsage events at this interval, specified in milliseconds
    :param transfer_mode: *(Optional)* Whether to report trace events as series of dataCollected events or to save trace to a stream (defaults to ```ReportEvents````).
    :param stream_format: *(Optional)* Trace data format to use. This only applies when using ````ReturnAsStream```` transfer mode (defaults to ````json````).
    :param stream_compression: **(EXPERIMENTAL)** *(Optional)* Compression format to use. This only applies when using ````ReturnAsStream```` transfer mode (defaults to ````none````)
    :param trace_config: *(Optional)*
    :param perfetto_config: **(EXPERIMENTAL)** *(Optional)* Base64-encoded serialized perfetto.protos.TraceConfig protobuf message When specified, the parameters ````categories````, ````options````, ````traceConfig```` are ignored. (Encoded as a base64 string when passed over JSON)
    :param tracing_backend: **(EXPERIMENTAL)** *(Optional)* Backend type (defaults to ````auto```)
    """
    params: T_JSON_DICT = dict()
    if categories is not None:
        params["categories"] = categories
    if options is not None:
        params["options"] = options
    if buffer_usage_reporting_interval is not None:
        params["bufferUsageReportingInterval"] = buffer_usage_reporting_interval
    if transfer_mode is not None:
        params["transferMode"] = transfer_mode
    if stream_format is not None:
        params["streamFormat"] = stream_format.to_json()
    if stream_compression is not None:
        params["streamCompression"] = stream_compression.to_json()
    if trace_config is not None:
        params["traceConfig"] = trace_config.to_json()
    if perfetto_config is not None:
        params["perfettoConfig"] = perfetto_config
    if tracing_backend is not None:
        params["tracingBackend"] = tracing_backend.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "Tracing.start",
        "params": params,
    }
    json = yield cmd_dict