| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // NOTE: No header guards are used, since this file is intended to be expanded |
| // directly into net_log.h. DO NOT include this file anywhere else. |
| // The following line silences a presubmit warning that would otherwise be |
| // triggered by this: |
| // no-include-guard-because-multiply-included |
| // NOLINT(build/header_guard) |
| |
| // In the event of a failure, many end events will have a |net_error| |
| // parameter with the integer error code associated with the failure. Most |
| // of these parameters are not individually documented. |
| // |
| // For best practices on how to add new NetLog events see: |
| // https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/net-log.md |
| |
| // -------------------------------------------------------------------------- |
| // General pseudo-events |
| // -------------------------------------------------------------------------- |
| |
| // Something got cancelled (we determine what is cancelled based on the |
| // log context around it.) |
| EVENT_TYPE(CANCELLED) |
| |
| // Something failed (we determine what failed based on the log context |
| // around it.) |
| // The event has the following parameters: |
| // |
| // { |
| // "net_error": <The net error code integer for the failure>, |
| // } |
| EVENT_TYPE(FAILED) |
| |
| // Marks the creation/destruction of a request (net::URLRequest). |
| EVENT_TYPE(REQUEST_ALIVE) |
| |
| // ------------------------------------------------------------------------ |
| // HostResolverManager (previously known as HostResolverImpl) |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a host resolve (DNS) request. Note that these events are |
| // logged for all DNS requests, though not all requests result in the creation |
| // of a HostResolvedImpl::Request object. |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "host": <Serialized scheme/host/port of the request>, |
| // "dns_query_type": <The type of the DNS query>, |
| // "allow_cached_response": <Whether it is ok to return a result from |
| // the host cache>, |
| // "is_speculative": <Whether this request was started by the DNS |
| // prefetcher>, |
| // "network_isolation_key": <NetworkAnonymizationKey associated with the |
| // request>, |
| // "secure_dns_policy": <SecureDnsPolicy of the request>, |
| // } |
| // |
| // If an error occurred, the END phase will contain these parameters: |
| // { |
| // "net_error": <The net error code integer for the failure>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_REQUEST) |
| |
| // This event is created (in a source of the same name) when the host resolver |
| // creates a UDP socket to check for global IPv6 connectivity. |
| // It contains the following parameter: |
| // |
| // { |
| // "ipv6_available": <True if the probe indicates ipv6 connectivity>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_IPV6_REACHABILITY_CHECK) |
| |
| // This event is logged when a request is handled by a cache entry. |
| // It contains the following parameter: |
| // { |
| // "results": <HostCache::Entry of results>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_CACHE_HIT) |
| |
| // This event is logged when a request is handled by a HOSTS entry. |
| // It contains the following parameter: |
| // { |
| // "results": <HostCache::Entry of results>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_HOSTS_HIT) |
| |
| // This event is logged when a bootstrap request matches a config preset entry. |
| // It contains the following parameter: |
| // { |
| // "results": <HostCache::Entry of results>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_CONFIG_PRESET_MATCH) |
| |
| // This event is created when a new HostResolverManager::Job is about to be |
| // created for a request. |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_CREATE_JOB) |
| |
| // The creation/completion of a HostResolverManager::Job which is created for |
| // Requests that cannot be resolved synchronously. |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "dns_query_type": <DnsQueryType of the job>, |
| // "host": <Serialized scheme/host/port associated with the job>, |
| // "network_isolation_key": <NetworkAnonymizationKey associated with the |
| // job>, "secure_dns_mode": <SecureDnsMode of the job>, "source_dependency": |
| // <Source id, if any, of what created the job>, |
| // } |
| // |
| // The END phase will contain these parameters: |
| // { |
| // "net_error": <The net error code integer for the failure>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_JOB) |
| |
| // This event is created when a HostResolverManager::Job is evicted from |
| // PrioritizedDispatcher before it can start, because the limit on number of |
| // queued Jobs was reached. |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_JOB_EVICTED) |
| |
| // This event is created when a HostResolverManager::Job is started by |
| // PrioritizedDispatcher. |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_JOB_STARTED) |
| |
| // This event is created when HostResolverManager::ProcTask is about to start a |
| // new attempt to resolve the host. |
| // |
| // The ATTEMPT_STARTED event has the parameters: |
| // |
| // { |
| // "attempt_number": <the number of the attempt that is resolving the host>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_ATTEMPT_STARTED) |
| |
| // This event is created when HostResolverManager::ProcTask has finished |
| // resolving the host. |
| // |
| // The ATTEMPT_FINISHED event has the parameters: |
| // |
| // { |
| // "attempt_number": <the number of the attempt that has resolved the host>, |
| // } |
| // If an error occurred, the END phase will contain these additional parameters: |
| // { |
| // "net_error": <The net error code integer for the failure>, |
| // "os_error": <The exact error code integer that getaddrinfo() returned>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_ATTEMPT_FINISHED) |
| |
| // This is logged for a request when it's attached to a |
| // HostResolverManager::Job. When this occurs without a preceding |
| // HOST_RESOLVER_MANAGER_CREATE_JOB entry, it means the request was attached to |
| // an existing HostResolverManager::Job. |
| // |
| // The event contains the following parameters: |
| // |
| // { |
| // "source_dependency": <Source identifier for the attached Job>, |
| // } |
| // |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_JOB_ATTACH) |
| |
| // This event is logged for the job to which the request is attached. |
| // In that case, the event contains the following parameters: |
| // |
| // { |
| // "source_dependency": <Source identifier for the attached Request>, |
| // "priority": <New priority of the job>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_JOB_REQUEST_ATTACH) |
| |
| // This is logged for a job when a request is cancelled and detached. |
| // |
| // The event contains the following parameters: |
| // |
| // { |
| // "source_dependency": <Source identifier for the detached Request>, |
| // "priority": <New priority of the job>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_JOB_REQUEST_DETACH) |
| |
| // The creation/completion of a HostResolverSystemTask to call getaddrinfo. The |
| // BEGIN phase contains the following parameters: |
| // |
| // { |
| // "hostname": <Hostname associated with the request>, |
| // } |
| // |
| // On success, the END phase has these parameters: |
| // { |
| // "address_list": <The resolved addresses>, |
| // } |
| // If an error occurred, the END phase will contain these parameters: |
| // { |
| // "net_error": <The net error code integer for the failure>, |
| // "os_error": <The exact error code integer that getaddrinfo() returned>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_SYSTEM_TASK) |
| |
| // The creation/completion of a HostResolverManager::DnsTask to manage a |
| // DnsTransaction. The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "secure": <Whether or not the task will use secure DNS>, |
| // "transactions_needed": [{ |
| // "dns_query_type": <DnsQueryType for which a transaction is expected>, |
| // }], |
| // } |
| // |
| // On success, the END phase has these parameters: |
| // { |
| // "results": <HostCache::Entry of results>, |
| // } |
| // If an error occurred, the END phase will contain these parameters: |
| // { |
| // "dns_query_type": <The DnsQueryType of the transaction that failed>, |
| // "error_ttl_sec": <TTL in seconds for caching the error>, |
| // "net_error": <The net error code integer for the failure>, |
| // "saved_results": <HostCache::Entry of any previously completed |
| // transactions>, |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_DNS_TASK) |
| |
| // Logged when DnsResponseResultExtractor returns an error to |
| // HostResolverManager::DnsTask when attempting to extract results from a |
| // DnsResponse. Contains the following parameters: |
| // |
| // { |
| // "extraction_error": <The DnsResponseResultExtractor::ExtractionError> |
| // "dns_query_type": <The DnsQueryType requested from the extractor> |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_DNS_TASK_EXTRACTION_FAILURE) |
| |
| // Logged when a HostResolverManager::DnsTask times out and cancels unfinished |
| // transactions. |
| // The event contains the following parameters: |
| // |
| // { |
| // "started_transactions": [{ |
| // "dns_query_type": <DnsQueryType of a started but incomplete |
| // transaction>, |
| // }], |
| // "queued_transactions": [{ |
| // "dns_query_type": <DnsQueryType of a not-yet-started transaction>, |
| // }], |
| // } |
| EVENT_TYPE(HOST_RESOLVER_MANAGER_DNS_TASK_TIMEOUT) |
| |
| // ------------------------------------------------------------------------ |
| // InitProxyResolver |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of auto-detect + custom PAC URL configuration. |
| EVENT_TYPE(PAC_FILE_DECIDER) |
| |
| // The start/end of when proxy autoconfig was artificially paused following |
| // a network change event. (We wait some amount of time after being told of |
| // network changes to avoid hitting spurious errors during auto-detect). |
| EVENT_TYPE(PAC_FILE_DECIDER_WAIT) |
| |
| // The start/end of download of a PAC script. This could be the well-known |
| // WPAD URL (if testing auto-detect), or a custom PAC URL. |
| // |
| // The START event has the parameters: |
| // { |
| // "source": <String describing where PAC script comes from>, |
| // } |
| // |
| // If the fetch failed, then the END phase has these parameters: |
| // { |
| // "net_error": <Net error code integer>, |
| // } |
| EVENT_TYPE(PAC_FILE_DECIDER_FETCH_PAC_SCRIPT) |
| |
| // This event means that initialization failed because there was no |
| // configured script fetcher. (This indicates a configuration error). |
| EVENT_TYPE(PAC_FILE_DECIDER_HAS_NO_FETCHER) |
| |
| // This event is emitted after deciding to fall-back to the next source |
| // of PAC scripts in the list. |
| EVENT_TYPE(PAC_FILE_DECIDER_FALLING_BACK_TO_NEXT_PAC_SOURCE) |
| |
| // ------------------------------------------------------------------------ |
| // ConfiguredProxyResolutionService |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a proxy resolve request. |
| EVENT_TYPE(PROXY_RESOLUTION_SERVICE) |
| |
| // The time while a request is waiting on InitProxyResolver to configure |
| // against either WPAD or custom PAC URL. The specifics on this time |
| // are found from ConfiguredProxyResolutionService::init_proxy_resolver_log(). |
| EVENT_TYPE(PROXY_RESOLUTION_SERVICE_WAITING_FOR_INIT_PAC) |
| |
| // This event is emitted to show what the PAC script returned. It can contain |
| // extra parameters that are either: |
| // { |
| // "pac_string": <List of valid proxy servers, in PAC format>, |
| // } |
| // |
| // Or if the the resolver failed: |
| // { |
| // "net_error": <Net error code that resolver failed with>, |
| // } |
| EVENT_TYPE(PROXY_RESOLUTION_SERVICE_RESOLVED_PROXY_LIST) |
| |
| // This event is emitted after proxies marked as bad have been deprioritized. |
| // |
| // It contains these parameters: |
| // { |
| // "pac_string": <List of valid proxy servers, in PAC format>, |
| // } |
| EVENT_TYPE(PROXY_RESOLUTION_SERVICE_DEPRIORITIZED_BAD_PROXIES) |
| |
| // This event is emitted whenever the proxy settings used by |
| // ConfiguredProxyResolutionService change. |
| // |
| // It contains these parameters: |
| // { |
| // "old_config": <Dump of the previous proxy settings>, |
| // "new_config": <Dump of the new proxy settings>, |
| // } |
| // |
| // Note that the "old_config" key will be omitted on the first fetch of the |
| // proxy settings (since there wasn't a previous value). |
| EVENT_TYPE(PROXY_CONFIG_CHANGED) |
| |
| // Emitted when a list of bad proxies is reported to the proxy service. |
| // |
| // Parameters: |
| // { |
| // "bad_proxy_list": <List of bad proxies>, |
| // } |
| EVENT_TYPE(BAD_PROXY_LIST_REPORTED) |
| |
| // ------------------------------------------------------------------------ |
| // ProxyList |
| // ------------------------------------------------------------------------ |
| |
| // Emitted when the first proxy server in a list is being marked as |
| // bad and proxy resolution is going to failover to the next one in |
| // the list. The fallback is local to the request. |
| // |
| // Parameters: |
| // { |
| // "bad_proxy": <URI representation of the failed proxy server>, |
| // } |
| EVENT_TYPE(PROXY_LIST_FALLBACK) |
| |
| // ------------------------------------------------------------------------ |
| // ProxyResolverV8Tracing |
| // ------------------------------------------------------------------------ |
| |
| // This event is emitted when a javascript error has been triggered by a |
| // PAC script. It contains the following event parameters: |
| // { |
| // "line_number": <The line number in the PAC script |
| // (or -1 if not applicable)>, |
| // "message": <The error message>, |
| // } |
| EVENT_TYPE(PAC_JAVASCRIPT_ERROR) |
| |
| // This event is emitted when a PAC script called alert(). It contains the |
| // following event parameters: |
| // { |
| // "message": <The string of the alert>, |
| // } |
| EVENT_TYPE(PAC_JAVASCRIPT_ALERT) |
| |
| // ------------------------------------------------------------------------ |
| // MultiThreadedProxyResolver |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time that a proxy resolve request was stalled waiting for a |
| // proxy resolver thread to free-up. |
| EVENT_TYPE(WAITING_FOR_PROXY_RESOLVER_THREAD) |
| |
| // This event is emitted just before a PAC request is bound to a thread. It |
| // contains these parameters: |
| // |
| // { |
| // "thread_number": <Identifier for the PAC thread that is going to |
| // run this request>, |
| // } |
| EVENT_TYPE(SUBMITTED_TO_RESOLVER_THREAD) |
| |
| // ------------------------------------------------------------------------ |
| // Socket (Shared by stream and datagram sockets) |
| // ------------------------------------------------------------------------ |
| |
| // Marks the begin/end of a socket (TCP/SOCKS/SSL/UDP/"SpdyProxyClientSocket"). |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "source_dependency": <Source identifier for the controlling entity>, |
| // } |
| EVENT_TYPE(SOCKET_ALIVE) |
| |
| // Records Open calls to sockets. |
| // { |
| // "net_error": <On failure; net integer error code> |
| // } |
| EVENT_TYPE(SOCKET_OPEN) |
| |
| // Records Connect calls to sockets. |
| // { |
| // "address": <Remote address being connected to> |
| // "net_error": <On failure; net integer error code> |
| // } |
| EVENT_TYPE(SOCKET_CONNECT) |
| |
| // Records BindToNetwork calls to sockets. |
| // { |
| // "network": <Network this socket is being bound to> |
| // "net_error": <On failure; net integer error code> |
| // } |
| EVENT_TYPE(SOCKET_BIND_TO_NETWORK) |
| |
| // ------------------------------------------------------------------------ |
| // Brokered Socket (Shared by stream and datagram sockets) |
| // ------------------------------------------------------------------------ |
| |
| // Marks the begin/end of a brokered socket (TCP/UDP) |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "source_dependency": <Source identifier for the controlling entity>, |
| // } |
| EVENT_TYPE(BROKERED_SOCKET_ALIVE) |
| |
| // The start/end of creating a new socketfd in the network service sandbox. This |
| // event is only used when a socket needs to be created outside of the network |
| // sandbox. |
| // |
| // The END event wil contain the following parameters: |
| // { |
| // "net_error": <Net integer error code> |
| // } |
| EVENT_TYPE(BROKERED_CREATE_SOCKET) |
| |
| // ------------------------------------------------------------------------ |
| // StreamSocket |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a TCP connect(). This corresponds with a call to |
| // TCPClientSocket::Connect(). |
| // |
| // The START event contains these parameters: |
| // |
| // { |
| // "address_list": <List of network address strings>, |
| // } |
| // |
| // And the END event will contain the following parameters: |
| // |
| // { |
| // "net_error": <Net integer error code, on error>, |
| // "source_address": <Local source address of the connection, on success>, |
| // } |
| EVENT_TYPE(TCP_CONNECT) |
| |
| // Nested within TCP_CONNECT, there may be multiple attempts to connect |
| // to the individual addresses. The START event will describe the |
| // address the attempt is for: |
| // |
| // { |
| // "address": <String of the network address>, |
| // } |
| // |
| // The END event will contain one of the following: |
| // |
| // On success: |
| // { |
| // "local_address": <The local address, as a string>, |
| // "remote_address": <The remote address, as a string>, |
| // } |
| // |
| // On success, but unable to determine the connected address: |
| // { |
| // "get_address_net_error": <Net integer error code>, |
| // } |
| // |
| // { |
| // "net_error": <Net integer error code>, |
| // } |
| EVENT_TYPE(TCP_CONNECT_ATTEMPT) |
| |
| // The start/end of a TCP accept(). This corresponds with a call to |
| // TCPServerSocket::Accept(). |
| // |
| // The END event will contain the following parameters on success: |
| // { |
| // "address": <Remote address of the accepted connection>, |
| // } |
| // On failure it contains the following parameters |
| // { |
| // "net_error": <Net integer error code>, |
| // } |
| EVENT_TYPE(TCP_ACCEPT) |
| |
| // This event is logged to the socket stream whenever the socket is |
| // acquired/released via a ClientSocketHandle. |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "source_dependency": <Source identifier for the controlling entity>, |
| // } |
| EVENT_TYPE(SOCKET_IN_USE) |
| |
| // The start/end of a SOCKS connect(). |
| EVENT_TYPE(SOCKS_CONNECT) |
| |
| // The start/end of a SOCKS5 connect(). |
| EVENT_TYPE(SOCKS5_CONNECT) |
| |
| // This event is emitted when the SOCKS connect fails because the provided |
| // was longer than 255 characters. |
| EVENT_TYPE(SOCKS_HOSTNAME_TOO_BIG) |
| |
| // These events are emitted when insufficient data was read while |
| // trying to establish a connection to the SOCKS proxy server |
| // (during the greeting phase or handshake phase, respectively). |
| EVENT_TYPE(SOCKS_UNEXPECTEDLY_CLOSED_DURING_GREETING) |
| EVENT_TYPE(SOCKS_UNEXPECTEDLY_CLOSED_DURING_HANDSHAKE) |
| |
| // This event indicates that a bad version number was received in the |
| // proxy server's response. The extra parameters show its value: |
| // { |
| // "version": <Integer version number in the response>, |
| // } |
| EVENT_TYPE(SOCKS_UNEXPECTED_VERSION) |
| |
| // This event indicates that the SOCKS proxy server returned an error while |
| // trying to create a connection. The following parameters will be attached |
| // to the event: |
| // { |
| // "error_code": <Integer error code returned by the server>, |
| // } |
| EVENT_TYPE(SOCKS_SERVER_ERROR) |
| |
| // This event indicates that the SOCKS proxy server asked for an authentication |
| // method that we don't support. The following parameters are attached to the |
| // event: |
| // { |
| // "method": <Integer method code>, |
| // } |
| EVENT_TYPE(SOCKS_UNEXPECTED_AUTH) |
| |
| // This event indicates that the SOCKS proxy server's response indicated an |
| // address type which we are not prepared to handle. |
| // The following parameters are attached to the event: |
| // { |
| // "address_type": <Integer code for the address type>, |
| // } |
| EVENT_TYPE(SOCKS_UNKNOWN_ADDRESS_TYPE) |
| |
| // The start/end of an SSL "connect" (aka client handshake). |
| // The following parameters are attached to the END event: |
| // |
| // { |
| // "version": <String name of the TLS version negotiated>, |
| // "cipher_suite": <Integer code for the cipher suite>, |
| // "is_resumed": <Whether we resumed a session>, |
| // "next_proto": <The next protocol negotiated via ALPN>, |
| // } |
| EVENT_TYPE(SSL_CONNECT) |
| |
| // Emitted at the start of an SSL handshakes that use ECH. The following |
| // parameters are attached. |
| // { |
| // "bytes": <The ECHConfigList used, base64 encoded> |
| // } |
| EVENT_TYPE(SSL_ECH_CONFIG_LIST) |
| |
| // The start/end of an SSL server handshake (aka "accept"). |
| EVENT_TYPE(SSL_SERVER_HANDSHAKE) |
| |
| // The SSL server requested a client certificate. |
| EVENT_TYPE(SSL_CLIENT_CERT_REQUESTED) |
| |
| // The SSL stack blocked on a private key operation. The following parameters |
| // are attached to the event. |
| // { |
| // "algorithm": <TLS signature algorithm used>, |
| // "provider": <Human-readable name of the crypto provider>, |
| // } |
| EVENT_TYPE(SSL_PRIVATE_KEY_OP) |
| |
| // A client certificate (or none) was provided to the SSL library to be sent |
| // to the SSL server. |
| // The following parameters are attached to the event: |
| // { |
| // "cert_count": <Number of certificates>, |
| // } |
| // A cert_count of 0 means no client certificate was provided. |
| // A cert_count of -1 means a client certificate was provided but we don't |
| // know the size of the certificate chain. |
| EVENT_TYPE(SSL_CLIENT_CERT_PROVIDED) |
| |
| // An SSL error occurred while trying to do the indicated activity. |
| // The following parameters are attached to the event: |
| // { |
| // "net_error": <Integer code for the specific error type>, |
| // "ssl_lib_error": <SSL library's integer code for the specific error type> |
| // } |
| EVENT_TYPE(SSL_HANDSHAKE_ERROR) |
| EVENT_TYPE(SSL_READ_ERROR) |
| EVENT_TYPE(SSL_WRITE_ERROR) |
| |
| // We found that our prediction of the server's certificates was correct and |
| // we merged the verification with the SSLHostInfo. (Note: now obsolete.) |
| EVENT_TYPE(SSL_VERIFICATION_MERGED) |
| |
| // An SSL connection sent or received an alert. |
| // The following parameters are attached: |
| // { |
| // "bytes": <The exact bytes sent, Base64 encoded> |
| // } |
| EVENT_TYPE(SSL_ALERT_RECEIVED) |
| EVENT_TYPE(SSL_ALERT_SENT) |
| |
| // The SSL connection is being confirmed. |
| EVENT_TYPE(SSL_CONFIRM_HANDSHAKE) |
| |
| // An SSL connection sent or received a handshake message. |
| // `SSL_ENCRYPTED_CLIENT_HELLO` means the handshake message was not sent over |
| // the wire but encrypted with the Encrypted ClientHello (ECH) extension. The |
| // following parameters are attached: |
| // { |
| // "type": <The type of the handshake message, as an integer> |
| // "bytes": <The exact bytes sent, Base64 encoded. |
| // May be elided in some cases> |
| // } |
| EVENT_TYPE(SSL_HANDSHAKE_MESSAGE_RECEIVED) |
| EVENT_TYPE(SSL_HANDSHAKE_MESSAGE_SENT) |
| EVENT_TYPE(SSL_ENCRYPTED_CLIENT_HELLO) |
| |
| // The specified number of bytes were sent on the socket. Depending on the |
| // source of the event, may be logged either once the data is sent, or when it |
| // is queued to be sent. |
| // The following parameters are attached: |
| // { |
| // "byte_count": <Number of bytes that were just sent>, |
| // "bytes": <The exact bytes sent, Base64 encoded. |
| // Only present when byte logging is enabled>, |
| // } |
| EVENT_TYPE(SOCKET_BYTES_SENT) |
| EVENT_TYPE(SSL_SOCKET_BYTES_SENT) |
| |
| // The specified number of bytes were received on the socket. |
| // The following parameters are attached: |
| // { |
| // "byte_count": <Number of bytes that were just received>, |
| // "bytes": <The exact bytes received, Base64 encoded. |
| // Only present when byte logging is enabled>, |
| // } |
| EVENT_TYPE(SOCKET_BYTES_RECEIVED) |
| EVENT_TYPE(SSL_SOCKET_BYTES_RECEIVED) |
| |
| // A socket error occurred while trying to do the indicated activity. |
| // The following parameters are attached to the event: |
| // { |
| // "net_error": <Integer code for the specific error type>, |
| // "os_error": <Integer error code the operating system returned> |
| // } |
| EVENT_TYPE(SOCKET_READ_ERROR) |
| EVENT_TYPE(SOCKET_WRITE_ERROR) |
| |
| // The socket was closed locally (The socket may or may not have been closed |
| // by the remote side already) |
| EVENT_TYPE(SOCKET_CLOSED) |
| |
| // Certificates were received from the SSL server (during a handshake or |
| // renegotiation). The following parameters are attached to the event: |
| // { |
| // "certificates": <A list of PEM encoded certificates in the order that |
| // they were sent by the server>, |
| // } |
| EVENT_TYPE(SSL_CERTIFICATES_RECEIVED) |
| |
| // Signed Certificate Timestamps were received from the server. |
| // The following parameters are attached to the event: |
| // { |
| // "embedded_scts": Base64-encoded SignedCertificateTimestampList, |
| // "scts_from_ocsp_response": Base64-encoded SignedCertificateTimestampList, |
| // "scts_from_tls_extension": Base64-encoded SignedCertificateTimestampList, |
| // } |
| // |
| // The SignedCertificateTimestampList is defined in RFC6962 and is exactly as |
| // received from the server. |
| EVENT_TYPE(SIGNED_CERTIFICATE_TIMESTAMPS_RECEIVED) |
| |
| // Signed Certificate Timestamps were checked. |
| // The following parameters are attached to the event: |
| // { |
| // "verified_scts": <A list of SCTs>, |
| // "invalid_scts": <A list of SCTs>, |
| // "scts_from_unknown_logs": <A list of SCTs>, |
| // } |
| // |
| // Where each SCT is an object: |
| // { |
| // "origin": <one of: "Embedded in certificate", "tls_extension", "ocsp">, |
| // "version": <numeric version>, |
| // "log_id": <base64-encoded log id>, |
| // "timestamp": <numeric timestamp in milliseconds since the Unix epoch>, |
| // "hash_algorithm": <name of the hash algorithm>, |
| // "signature_algorithm": <name of the signature algorithm>, |
| // "signature_data": <base64-encoded signature bytes>, |
| // } |
| EVENT_TYPE(SIGNED_CERTIFICATE_TIMESTAMPS_CHECKED) |
| |
| // The certificate was checked for compliance with Certificate Transparency |
| // requirements. |
| // |
| // The following parameters are attached to the event: |
| // { |
| // "certificate": <An X.509 certificate, same format as in |
| // CERT_VERIFIER_JOB.> |
| // "build_timely": <boolean> |
| // "ct_compliance_status": <string describing compliance status> |
| // } |
| EVENT_TYPE(CERT_CT_COMPLIANCE_CHECKED) |
| |
| // A Certificate Transparency log entry was audited for inclusion in the |
| // log. |
| // |
| // The following parameters are attached to the event: |
| // { |
| // "log_entry": <hex-encoded hash of the log entry> |
| // "log_id": <hex-encoded hash of the CT log> |
| // "success": <boolean> |
| // } |
| |
| EVENT_TYPE(CT_LOG_ENTRY_AUDITED) |
| |
| // ------------------------------------------------------------------------ |
| // DatagramSocket |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a UDP client connecting. |
| // |
| // The START event contains these parameters: |
| // |
| // { |
| // "address": <Remote address being connected to>, |
| // "bound_to_network": <optional; network handle for the network that this |
| // socket is bound to. Only present when this socket |
| // is bound to a network.> |
| // } |
| // |
| // And the END event will contain the following parameter: |
| // |
| // { |
| // "net_error": <Net integer error code, on failure>, |
| // } |
| EVENT_TYPE(UDP_CONNECT) |
| |
| // The local address of the UDP socket, retrieved via getsockname. |
| // The following parameters are attached: |
| // { |
| // "address": <Local address bound to the socket>, |
| // "bound_to_network": <optional; network handle for the network that this |
| // socket is bound to. Only present when this socket |
| // is bound to a network.> |
| // } |
| EVENT_TYPE(UDP_LOCAL_ADDRESS) |
| |
| // The specified number of bytes were transferred on the socket. |
| // The following parameters are attached: |
| // { |
| // "address": <Remote address of data transfer. Not present when not |
| // specified for UDP_BYTES_SENT events>, |
| // "byte_count": <Number of bytes that were just received>, |
| // "bytes": <The exact bytes received, Base64 encoded. |
| // Only present when byte logging is enabled>, |
| // } |
| EVENT_TYPE(UDP_BYTES_RECEIVED) |
| EVENT_TYPE(UDP_BYTES_SENT) |
| |
| // Logged when an error occurs while reading or writing to/from a UDP socket. |
| // The following parameters are attached: |
| // { |
| // "net_error": <Net error code>, |
| // } |
| EVENT_TYPE(UDP_RECEIVE_ERROR) |
| EVENT_TYPE(UDP_SEND_ERROR) |
| |
| // ------------------------------------------------------------------------ |
| // ConnectJob |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a ConnectJob. |
| EVENT_TYPE(CONNECT_JOB) |
| |
| // This event is logged whenever the ConnectJob gets a new socket |
| // association. The event parameters point to that socket: |
| // |
| // { |
| // "source_dependency": <The source identifier for the new socket.>, |
| // } |
| EVENT_TYPE(CONNECT_JOB_SET_SOCKET) |
| |
| // Whether the connect job timed out. |
| EVENT_TYPE(CONNECT_JOB_TIMED_OUT) |
| |
| // ------------------------------------------------------------------------ |
| // ConnectJob subclasses |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of the TransportConnectJob::Connect(). |
| EVENT_TYPE(TRANSPORT_CONNECT_JOB_CONNECT) |
| |
| // The start/end of the SSLConnectJob::Connect(). |
| EVENT_TYPE(SSL_CONNECT_JOB_CONNECT) |
| |
| // The start/end of the SOCKSConnectJob::Connect(). |
| EVENT_TYPE(SOCKS_CONNECT_JOB_CONNECT) |
| |
| // The start/end of the HttpProxyConnectJob::Connect(). |
| EVENT_TYPE(HTTP_PROXY_CONNECT_JOB_CONNECT) |
| |
| // A TLS connection attempt failed because ECH was not negotiated. The |
| // connection will be retried with a new ECHConfigList from the client-facing |
| // server. If the new ECHConfigList is the empty string, the server has rolled |
| // back ECH and the new attempt will have ECH disabled. |
| // |
| // { |
| // "bytes": <The new ECHConfigList, base64-encoded> |
| // } |
| EVENT_TYPE(SSL_CONNECT_JOB_RESTART_WITH_ECH_CONFIG_LIST) |
| |
| // This event is logged when the TransportConnectJob IPv6 fallback timer expires |
| // and the IPv4 addresses are attempted. |
| EVENT_TYPE(TRANSPORT_CONNECT_JOB_IPV6_FALLBACK) |
| |
| // This event is logged whenever the ConnectJob attempts a new TCP connection. |
| // association. The ConnectJob may attempt multiple addresses in parallel, so |
| // this event does not log when the connection attempt succeeds or fails. The |
| // source dependency may be used to determine this. |
| // |
| // { |
| // "address": <String of the network address being attempted>, |
| // "source_dependency": <The source identifier for the new socket.>, |
| // } |
| EVENT_TYPE(TRANSPORT_CONNECT_JOB_CONNECT_ATTEMPT) |
| |
| // ------------------------------------------------------------------------ |
| // ClientSocketPoolBaseHelper |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a client socket pool request for a socket. |
| EVENT_TYPE(SOCKET_POOL) |
| |
| // The request stalled because there are too many sockets in the pool. |
| EVENT_TYPE(SOCKET_POOL_STALLED_MAX_SOCKETS) |
| |
| // The request stalled because there are too many sockets in the group. |
| EVENT_TYPE(SOCKET_POOL_STALLED_MAX_SOCKETS_PER_GROUP) |
| |
| // Indicates that we reused an existing socket. Attached to the event are |
| // the parameters: |
| // { |
| // "idle_ms": <The number of milliseconds the socket was sitting idle for>, |
| // } |
| EVENT_TYPE(SOCKET_POOL_REUSED_AN_EXISTING_SOCKET) |
| |
| // This event simply describes the host:port that were requested from the |
| // socket pool. Its parameters are: |
| // { |
| // "group_id": <The group id for the socket request>, |
| // } |
| EVENT_TYPE(TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET) |
| |
| // This event simply describes the host:port that were requested from the |
| // socket pool. Its parameters are: |
| // { |
| // "group_id": <The group id for the socket request>, |
| // } |
| EVENT_TYPE(TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKETS) |
| |
| // A connect job is created by a socket pool. Its parameters are: |
| // { |
| // "backup_job": <Whether this is a backup job created because the other |
| // ConnectJob was taking too long>, |
| // "group_id": <The group id for the socket request>, |
| // } |
| EVENT_TYPE(SOCKET_POOL_CONNECT_JOB_CREATED) |
| |
| // This event is sent when a connect job is eventually bound to a request |
| // (because of late binding and socket backup jobs, we don't assign the job to |
| // a request until it has completed). |
| // |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the connect job we are |
| // bound to>, |
| // } |
| EVENT_TYPE(SOCKET_POOL_BOUND_TO_CONNECT_JOB) |
| |
| // Identifies the NetLogSource() for the Socket assigned to the pending |
| // request. The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the socket we acquired>, |
| // } |
| EVENT_TYPE(SOCKET_POOL_BOUND_TO_SOCKET) |
| |
| // The start/end of a client socket pool request for multiple sockets. |
| // The event parameters are: |
| // { |
| // "num_sockets": <Number of sockets we're trying to ensure are connected>, |
| // } |
| EVENT_TYPE(SOCKET_POOL_CONNECTING_N_SOCKETS) |
| |
| // Logged when a socket pool is closing a socket: |
| // { |
| // "reason": <Reason the socket was closed>, |
| // } |
| EVENT_TYPE(SOCKET_POOL_CLOSING_SOCKET) |
| |
| // ------------------------------------------------------------------------ |
| // URLRequest |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time it took a net::URLRequestJob to start. For the most part |
| // this corresponds with the time between net::URLRequest::Start() and |
| // net::URLRequest::ResponseStarted(), however it is also repeated for every |
| // redirect, and every intercepted job that handles the request. |
| // |
| // For the BEGIN phase, the following parameters are attached: |
| // { |
| // "url": <String of URL being loaded>, |
| // "method": <The method ("POST" or "GET" or "HEAD" etc..)>, |
| // "initiator": <Initiator origin of the request, if any, or else "not an |
| // origin">, |
| // "load_flags": <Numeric value of the combined load flags>, |
| // "network_isolation_key": <NIK associated with the request>, |
| // "request_type": <Type of the request, which is "main frame", "subframe", |
| // or "other">, |
| // "priority": <Numeric priority of the request>, |
| // "site_for_cookies": <SiteForCookies associated with the request>, |
| // "traffic_annotation": <int32 for the request's TrafficAnnotationTag>, |
| // "upload_id" <String of upload body identifier, if present>, |
| // } |
| // |
| // For the END phase, if there was an error, the following parameters are |
| // attached: |
| // { |
| // "net_error": <Net error code of the failure>, |
| // } |
| EVENT_TYPE(URL_REQUEST_START_JOB) |
| |
| // This event is sent once a net::URLRequest receives a redirect. The parameters |
| // attached to the event are: |
| // { |
| // "location": <The URL that was redirected to>, |
| // } |
| EVENT_TYPE(URL_REQUEST_REDIRECTED) |
| |
| // Measures the time between when a net::URLRequest calls a delegate that can |
| // block it, and when the delegate allows the request to resume. Each delegate |
| // type has a corresponding event type. |
| EVENT_TYPE(NETWORK_DELEGATE_BEFORE_START_TRANSACTION) |
| EVENT_TYPE(NETWORK_DELEGATE_BEFORE_URL_REQUEST) |
| EVENT_TYPE(NETWORK_DELEGATE_HEADERS_RECEIVED) |
| EVENT_TYPE(URL_REQUEST_DELEGATE_CERTIFICATE_REQUESTED) |
| EVENT_TYPE(URL_REQUEST_DELEGATE_RECEIVED_REDIRECT) |
| EVENT_TYPE(URL_REQUEST_DELEGATE_RESPONSE_STARTED) |
| EVENT_TYPE(URL_REQUEST_DELEGATE_SSL_CERTIFICATE_ERROR) |
| |
| // Like the above events, but the END phase also has the following parameter: |
| // { |
| // "net_error": <Network error code. Only present on error. |
| // } |
| EVENT_TYPE(URL_REQUEST_DELEGATE_CONNECTED) |
| |
| // Logged when a delegate informs the URL_REQUEST of what's currently blocking |
| // the request. The parameters attached to the begin event are: |
| // { |
| // "delegate_blocked_by": <Information about what's blocking the request>, |
| // } |
| EVENT_TYPE(DELEGATE_INFO) |
| |
| // The specified number of bytes were read from the net::URLRequest. |
| // The filtered event is used when the bytes were passed through a filter before |
| // being read. This event is only present when byte logging is enabled. |
| // The following parameters are attached: |
| // { |
| // "byte_count": <Number of bytes that were just sent>, |
| // "bytes": <The exact bytes sent, Base64 encoded>, |
| // } |
| EVENT_TYPE(URL_REQUEST_JOB_BYTES_READ) |
| EVENT_TYPE(URL_REQUEST_JOB_FILTERED_BYTES_READ) |
| |
| // This event is sent when the priority of a net::URLRequest is |
| // changed after it has started. The following parameters are attached: |
| // { |
| // "priority": <Numerical value of the priority (higher is more important)>, |
| // } |
| EVENT_TYPE(URL_REQUEST_SET_PRIORITY) |
| |
| EVENT_TYPE(URL_REQUEST_REDIRECT_JOB) |
| // This event is logged when a URLRequestRedirectJob is started for a request. |
| // The following parameters are attached: |
| // { |
| // "reason": <Reason for the redirect, as a string>, |
| // } |
| |
| EVENT_TYPE(URL_REQUEST_FAKE_RESPONSE_HEADERS_CREATED) |
| // This event is logged when a URLRequestRedirectJob creates the fake response |
| // headers for a request, prior to returning them. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| |
| EVENT_TYPE(URL_REQUEST_FILTERS_SET) |
| // This event is logged when a URLRequestJob sets up the filters, if any |
| // filters were added to the job. It logs the filters added. |
| // The following parameters are attached: |
| // { |
| // "filters": <The list of filter names> |
| // } |
| |
| // ------------------------------------------------------------------------ |
| // HttpCache |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time while getting a reference to the back end. |
| EVENT_TYPE(HTTP_CACHE_GET_BACKEND) |
| |
| // Measures the time while getting a disk cache entry with OpenOrCreateEntry(). |
| // The following parameters are attached: |
| // { |
| // "net_error": <Network error code. Only present on error>, |
| // "result": <"opened" or "created". Only present on success> |
| // } |
| EVENT_TYPE(HTTP_CACHE_OPEN_OR_CREATE_ENTRY) |
| |
| // Measures the time while opening a disk cache entry. |
| EVENT_TYPE(HTTP_CACHE_OPEN_ENTRY) |
| |
| // Measures the time while creating a disk cache entry. |
| EVENT_TYPE(HTTP_CACHE_CREATE_ENTRY) |
| |
| // Measures the time it takes to add a HttpCache::Transaction to an http cache |
| // entry's list of active Transactions. |
| EVENT_TYPE(HTTP_CACHE_ADD_TO_ENTRY) |
| |
| // Measures the time while deleting a disk cache entry. |
| EVENT_TYPE(HTTP_CACHE_DOOM_ENTRY) |
| |
| // Measures the time while reading/writing a disk cache entry's response headers |
| // or metadata. |
| EVENT_TYPE(HTTP_CACHE_READ_INFO) |
| EVENT_TYPE(HTTP_CACHE_WRITE_INFO) |
| |
| // Measures the time while reading/writing a disk cache entry's body. |
| EVENT_TYPE(HTTP_CACHE_READ_DATA) |
| EVENT_TYPE(HTTP_CACHE_WRITE_DATA) |
| |
| // The request headers received by the HTTP cache. |
| // The following parameters are attached: |
| // { |
| // "line": <empty>, |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_CACHE_CALLER_REQUEST_HEADERS) |
| |
| // Signal a significant change on the flow of the state machine: start again |
| // from scratch or create a new network request for byte-range operations. |
| // There are no parameters. |
| EVENT_TYPE(HTTP_CACHE_RESTART_PARTIAL_REQUEST) |
| EVENT_TYPE(HTTP_CACHE_RE_SEND_PARTIAL_REQUEST) |
| |
| // ------------------------------------------------------------------------ |
| // Disk Cache / Memory Cache |
| // ------------------------------------------------------------------------ |
| |
| // The creation/destruction of a disk_cache::EntryImpl object. The "creation" |
| // is considered to be the point at which an Entry is first considered to be |
| // good and associated with a key. Note that disk and memory cache entries |
| // share event types. |
| // |
| // For the BEGIN phase, the following parameters are attached: |
| // { |
| // "created": <true if the Entry was created, rather than being opened>, |
| // "key": <The Entry's key>, |
| // } |
| EVENT_TYPE(DISK_CACHE_ENTRY_IMPL) |
| EVENT_TYPE(DISK_CACHE_MEM_ENTRY_IMPL) |
| |
| // Logs the time required to read/write data from/to a cache entry. |
| // |
| // For the BEGIN phase, the following parameters are attached: |
| // { |
| // "index": <Index being read/written>, |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // "truncate": <If present for a write, the truncate flag is set to true. |
| // Not present in reads or writes where it is false>, |
| // } |
| // |
| // For the END phase, the following parameters are attached: |
| // { |
| // "bytes_copied": <Number of bytes copied. Not present on error>, |
| // "net_error": <Network error code. Only present on error>, |
| // } |
| EVENT_TYPE(ENTRY_READ_DATA) |
| EVENT_TYPE(ENTRY_WRITE_DATA) |
| |
| // Logged when sparse read/write operation starts/stops for an Entry. |
| // |
| // For the BEGIN phase, the following parameters are attached: |
| // { |
| // "offset": <Offset at which to start reading>, |
| // "buf_len": <Bytes to read/write>, |
| // } |
| EVENT_TYPE(SPARSE_READ) |
| EVENT_TYPE(SPARSE_WRITE) |
| |
| // Logged when a parent Entry starts/stops reading/writing a child Entry's data. |
| // |
| // For the BEGIN phase, the following parameters are attached: |
| // { |
| // "source_dependency": <Source id of the child entry>, |
| // "child_len": <Bytes to read/write from/to child>, |
| // } |
| EVENT_TYPE(SPARSE_READ_CHILD_DATA) |
| EVENT_TYPE(SPARSE_WRITE_CHILD_DATA) |
| |
| // Logged when sparse GetAvailableRange operation starts/stops for an Entry. |
| // |
| // For the BEGIN phase, the following parameters are attached: |
| // { |
| // "buf_len": <Bytes to read/write>, |
| // "offset": <Offset at which to start reading>, |
| // } |
| // |
| // For the END phase, the following parameters are attached. No parameters are |
| // attached when cancelled: |
| // { |
| // "length": <Length of returned range. Only present on success>, |
| // "start": <Position where returned range starts. Only present on success>, |
| // "net_error": <Resulting error code. Only present on failure. This may be |
| // "OK" when there's no error, but no available bytes in the |
| // range>, |
| // } |
| EVENT_TYPE(SPARSE_GET_RANGE) |
| |
| // Indicates the children of a sparse EntryImpl are about to be deleted. |
| // Not logged for MemEntryImpls. |
| EVENT_TYPE(SPARSE_DELETE_CHILDREN) |
| |
| // Logged when an EntryImpl is closed. Not logged for MemEntryImpls. |
| EVENT_TYPE(ENTRY_CLOSE) |
| |
| // Logged when an entry is doomed. |
| EVENT_TYPE(ENTRY_DOOM) |
| |
| // ------------------------------------------------------------------------ |
| // HttpStreamFactory |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time taken to fulfill the HttpStreamRequest. |
| EVENT_TYPE(HTTP_STREAM_REQUEST) |
| |
| // Measures the time taken to execute the HttpStreamFactory::Job |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the Request with started |
| // this Job>, |
| // "original_url": <The URL to create a stream for>, |
| // "url": <The URL actually being used, possibly different from |
| // original_url if using an alternate service>, |
| // "expect_spdy": <Boolean indicating whether the Job will use SPDY>, |
| // "using_quic": <Boolean indicating whether the Job will use QUIC>, |
| // "priority": <The priority of the Job>, |
| // "type": <The type of this Job ("main", "alternative", "dns_alpn_h3", |
| // "preconnect")>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB) |
| |
| // Measures the time and HttpStreamFactory::Job spends waiting for another job. |
| // The event parameters are: |
| // { |
| // "should_wait": <True if the job needs to wait>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_WAITING) |
| |
| // Identifies the NetLogSource() for a Job started by the Request. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for Job we started>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_REQUEST_STARTED_JOB) |
| |
| // Emitted when a job is throttled. |
| EVENT_TYPE(HTTP_STREAM_JOB_THROTTLED) |
| |
| // Emitted when a job resumes initializing a connection after being previously |
| // throttled. |
| EVENT_TYPE(HTTP_STREAM_JOB_RESUME_INIT_CONNECTION) |
| |
| // Emitted when a job is asked to initialize a connection. |
| EVENT_TYPE(HTTP_STREAM_JOB_INIT_CONNECTION) |
| |
| // Identifies the NetLogSource() for the Job that fulfilled the Request. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for Job we acquired>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_REQUEST_BOUND_TO_JOB) |
| |
| // Identifies the NetLogSource() for the QuicStreamFactory::Job that the |
| // HttpStreamFactory::Job was attached to. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the QuicStreamFactory::Job |
| // to which we were attached>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_BOUND_TO_QUIC_STREAM_FACTORY_JOB) |
| |
| // Identifies the NetLogSource() for the Request that the Job was attached to. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the Request to which we were |
| // attached>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_BOUND_TO_REQUEST) |
| |
| // Logs the protocol negotiated with the server. The event parameters are: |
| // { |
| // "proto": <The ALPN protocol negotiated>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_REQUEST_PROTO) |
| |
| // Emitted when a Job is orphaned because the Request was bound to a different |
| // Job. The orphaned Job will continue to run to completion. |
| EVENT_TYPE(HTTP_STREAM_JOB_ORPHANED) |
| |
| // Emitted when a job is delayed. |
| // { |
| // "delay_ms": <Number of milliseconds until job will be resumed> |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_DELAYED) |
| |
| // Emitted when a job is asked to resume after non-zero microseconds. |
| // { |
| // "delay_ms": <Number of milliseconds the job was delayed before resuming> |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_RESUMED) |
| |
| // Marks the start/end of a HttpStreamFactory::JobController. |
| // The following parameters are attached: |
| // { |
| // "url": <String of request URL>, |
| // "is_preconnect": <True if controller is created for a preconnect>, |
| // "private_mode": <Privacy mode of the request>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_CONTROLLER) |
| |
| // Links a JobController with its user (a URL_REQUEST). |
| // The event parameters are: |
| // { |
| // "source_dependency": <The source identifier for JobController if the |
| // event is logged in URL_REQUEST or the source identifier for the |
| // URL_REQUEST if the event is logged in HTTP_STREAM_JOB_CONTROLLER>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_CONTROLLER_BOUND) |
| |
| // Logs the proxy server resolved for the controller. The event parameters are: |
| // { |
| // "proxy_server": The proxy server resolved for the Job, |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_CONTROLLER_PROXY_SERVER_RESOLVED) |
| |
| // Logs an alternative service found by the controller. The event parameters |
| // are: |
| // { |
| // "alt_svc": The alternative service. |
| // "broken": <boolean> |
| // } |
| EVENT_TYPE(HTTP_STREAM_JOB_CONTROLLER_ALT_SVC_FOUND) |
| |
| // ------------------------------------------------------------------------ |
| // HttpNetworkTransaction |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time taken to send the tunnel request to the server. |
| EVENT_TYPE(HTTP_TRANSACTION_TUNNEL_SEND_REQUEST) |
| |
| // This event is sent for a tunnel request. |
| // The following parameters are attached: |
| // { |
| // "line": <The HTTP request line, CRLF terminated>, |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_SEND_TUNNEL_HEADERS) |
| |
| // Measures the time to read the tunnel response headers from the server. |
| EVENT_TYPE(HTTP_TRANSACTION_TUNNEL_READ_HEADERS) |
| |
| // This event is sent on receipt of the HTTP response headers to a tunnel |
| // request. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS) |
| |
| // Measures the time taken to send the request to the server. |
| EVENT_TYPE(HTTP_TRANSACTION_SEND_REQUEST) |
| |
| // This event is sent for a HTTP request. |
| // The following parameters are attached: |
| // { |
| // "line": <The HTTP request line, CRLF terminated>, |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_SEND_REQUEST_HEADERS) |
| |
| // Logged when a request body is sent. |
| // The following parameters are attached: |
| // { |
| // "did_merge": <True if the body was merged with the headers for writing>, |
| // "is_chunked": <True if chunked>, |
| // "length": <The length of the body. May not be accurate when body is not |
| // in memory> |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_SEND_REQUEST_BODY) |
| |
| // This event is sent for a HTTP request over an HTTP/2 stream. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_HTTP2_SEND_REQUEST_HEADERS) |
| |
| // This event is sent for a HTTP request over a QUIC stream. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // "quic_priority": <Integer representing the priority of this request>, |
| // "quic_stream_id": <Id of the QUIC stream sending this request>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS) |
| |
| // Measures the time to read HTTP response headers from the server. |
| EVENT_TYPE(HTTP_TRANSACTION_READ_HEADERS) |
| |
| // This event is sent on receipt of the HTTP response headers. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_READ_RESPONSE_HEADERS) |
| |
| // This event is sent on receipt of a 103 Early Hints response headers. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_READ_EARLY_HINTS_RESPONSE_HEADERS) |
| |
| // Measures the time to read the entity body from the server. |
| EVENT_TYPE(HTTP_TRANSACTION_READ_BODY) |
| |
| // Measures the time taken to read the response out of the socket before |
| // restarting for authentication, on keep alive connections. |
| EVENT_TYPE(HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART) |
| |
| // This event is sent when we try to restart a transaction after an error. |
| // The following parameters are attached: |
| // { |
| // "net_error": <The net error code integer for the failure, if applicable>, |
| // "http_status_code": <HTTP status code indicating an error, if |
| // applicable>, |
| // } |
| EVENT_TYPE(HTTP_TRANSACTION_RESTART_AFTER_ERROR) |
| |
| // This event is sent when we try to restart a transaction after the initial |
| // attempt failed with HTTP 421 Misdirected Requested. |
| EVENT_TYPE(HTTP_TRANSACTION_RESTART_MISDIRECTED_REQUEST) |
| |
| // ------------------------------------------------------------------------ |
| // BidirectionalStream |
| // ------------------------------------------------------------------------ |
| |
| // Marks the creation/destruction of a net::BidirectionalStream. |
| // The following parameters are attached: |
| // { |
| // "url": <The URL being used>, |
| // "method": <The HTTP method being used>, |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_ALIVE) |
| |
| // Marks the ReadData call of a net::BidirectionalStream. |
| // The following parameters are attached: |
| // { |
| // "rv": <The value in int that is returned to the caller> |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_READ_DATA) |
| |
| // Marks the SendvData call of a net::BidirectionalStream. |
| // The following parameters are attached: |
| // { |
| // "num_buffers": <The number of buffers passed to SendvData> |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_SENDV_DATA) |
| |
| // Marks the beginning/end of buffers sent in a net::BidirectionalStream. |
| // The following parameters are attached: |
| // { |
| // "num_buffers_coalesced": <number of buffers that were sent together>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED) |
| |
| // The specified number of bytes were sent on the stream. Depending on the |
| // source of the event, may be logged either once the data is sent, or when it |
| // is queued to be sent. |
| // The following parameters are attached: |
| // { |
| // "byte_count": <Number of bytes that were just sent>, |
| // "bytes": <The exact bytes sent, Base64 encoded. |
| // Only present when byte logging is enabled>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_BYTES_SENT) |
| |
| // The specified number of bytes were received on the stream. |
| // The following parameters are attached: |
| // { |
| // "byte_count": <Number of bytes that were just received>, |
| // "bytes": <The exact bytes received, Base64 encoded. |
| // Only present when byte logging is enabled>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_BYTES_RECEIVED) |
| |
| // This event is sent for receiving headers on the stream. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_RECV_HEADERS) |
| |
| // This event is sent for receiving trailers on the stream. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_RECV_TRAILERS) |
| |
| // This event is used when stream is successfully negotiated and is ready for |
| // sending data and reading data. |
| // The following parameters are attached: |
| // { |
| // "request_headers_sent": <boolean>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_READY) |
| |
| // This event is used when stream has failed. |
| // The following parameters are attached: |
| // { |
| // "net_error": <Net error code for the failure>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_FAILED) |
| |
| // Identifies the NetLogSource() for the QuicSession that handled the stream. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for session that was used>, |
| // } |
| EVENT_TYPE(BIDIRECTIONAL_STREAM_BOUND_TO_QUIC_SESSION) |
| |
| // ------------------------------------------------------------------------ |
| // SERVER_PUSH_LOOKUP_TRANSACTION |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a push lookup transaction for server push. |
| // |
| // The START event has the parameters: |
| // { |
| // "source_dependency": <Source identifier for the server push lookp. |
| // It can be a QUIC_SESSION or a HTTP2_SESSION>, |
| // "pushed_url": <The url that has been pushed and looked up>, |
| // } |
| // |
| // If the transaction doesn't find the resource in cache, then the END phase |
| // has these parameters: |
| // { |
| // "net_error": <Net error code integer>, |
| // } |
| EVENT_TYPE(SERVER_PUSH_LOOKUP_TRANSACTION) |
| |
| // ------------------------------------------------------------------------ |
| // SpdySession |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a SpdySession. |
| // { |
| // "host": <The host-port string>, |
| // "proxy": <The Proxy PAC string>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION) |
| |
| // The SpdySession has been initialized with a socket. |
| // { |
| // "source_dependency": <Source identifier for the underlying socket>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_INITIALIZED) |
| |
| // This event is sent for sending an HTTP/2 HEADERS frame. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // "fin": <True if this is the final data set by the peer on this stream>, |
| // "stream_id": <The stream id>, |
| // "has_priority": <True if the PRIORITY flag is set>, |
| // "parent_stream_id": <Optional; the stream id of the parent stream>, |
| // "priority": <Optional; the priority value of the stream>, |
| // "exclusive": <Optional; true if the exclusive bit is set>. |
| // } |
| EVENT_TYPE(HTTP2_SESSION_SEND_HEADERS) |
| |
| // This event is sent for receiving an HTTP/2 HEADERS frame. |
| // The following parameters are attached: |
| // { |
| // "flags": <The control frame flags>, |
| // "headers": <The list of header:value pairs>, |
| // "id": <The stream id>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_HEADERS) |
| |
| // On sending an HTTP/2 SETTINGS frame without ACK flag. |
| // The following parameters are attached: |
| // { |
| // "settings": <The list of setting ids and values>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_SEND_SETTINGS) |
| |
| // On sending an HTTP/2 SETTINGS frame with ACK flag. |
| EVENT_TYPE(HTTP2_SESSION_SEND_SETTINGS_ACK) |
| |
| // Receipt of an HTTP/2 ACCEPT_CH frame. |
| // The following parameters are attached: |
| // { |
| // "origin": <The origin associated with the settings>, |
| // "accept_ch": <the raw ACCEPT_CH setting for that origin>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_ACCEPT_CH) |
| |
| // Receipt of an HTTP/2 SETTINGS frame without ACK flag. |
| EVENT_TYPE(HTTP2_SESSION_RECV_SETTINGS) |
| |
| // Receipt of an individual HTTP/2 setting. |
| // The following parameters are attached: |
| // { |
| // "id": <The setting id>, |
| // "value": <The setting value>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_SETTING) |
| |
| // Receipt of an HTTP/2 SETTINGS frame with ACK flag. |
| EVENT_TYPE(HTTP2_SESSION_RECV_SETTINGS_ACK) |
| |
| // The receipt of a RST_STREAM frame. |
| // The following parameters are attached: |
| // { |
| // "stream_id": <The stream ID for the RST_STREAM>, |
| // "error_code": <Error code>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_RST_STREAM) |
| |
| // Sending of a RST_STREAM |
| // The following parameters are attached: |
| // { |
| // "stream_id": <The stream ID for the RST_STREAM>, |
| // "error_code": <Error code>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_SEND_RST_STREAM) |
| |
| // Sending of an HTTP/2 PING frame. |
| // The following parameters are attached: |
| // { |
| // "unique_id": <The unique id of the PING message>, |
| // "type": <The PING type ("sent", "received")>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_PING) |
| |
| // Receipt of an HTTP/2 GOAWAY frame. |
| // The following parameters are attached: |
| // { |
| // "last_accepted_stream_id": <Last stream id accepted by the server, duh>, |
| // "active_streams": <Number of active streams>, |
| // "unclaimed_streams": <Number of unclaimed push streams>, |
| // "error_code": <Error code>, |
| // "debug_data": <Additional debug data>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_GOAWAY) |
| |
| // Receipt of an HTTP/2 WINDOW_UPDATE frame (which controls the send window). |
| // { |
| // "stream_id": <The stream ID for the window update>, |
| // "delta" : <The delta window size>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_WINDOW_UPDATE) |
| |
| // Sending of an HTTP/2 WINDOW_UPDATE frame (which controls the |
| // receive window). |
| // { |
| // "stream_id": <The stream ID for the window update>, |
| // "delta" : <The delta window size>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_SEND_WINDOW_UPDATE) |
| |
| // This event indicates that the send window has been updated for a session. |
| // { |
| // "delta": <The window size delta>, |
| // "new_window": <The new window size>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_UPDATE_SEND_WINDOW) |
| |
| // This event indicates that the recv window has been updated for a session. |
| // { |
| // "delta": <The window size delta>, |
| // "new_window": <The new window size>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_UPDATE_RECV_WINDOW) |
| |
| // This event indicates that an invalid response header has been received. |
| // { |
| // "header_name": <The header name>, |
| // "header_value": <The header value>, |
| // "error": <Error message>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_INVALID_HEADER) |
| |
| // Sending a data frame |
| // { |
| // "stream_id": <The stream ID for the window update>, |
| // "length" : <The size of data sent>, |
| // "flags" : <Send data flags>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_SEND_DATA) |
| |
| // Receiving a data frame |
| // { |
| // "stream_id": <The stream ID for the window update>, |
| // "length" : <The size of data received>, |
| // "flags" : <Receive data flags>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_RECV_DATA) |
| |
| // A stream is stalled by the session send window being closed. |
| EVENT_TYPE(HTTP2_SESSION_STREAM_STALLED_BY_SESSION_SEND_WINDOW) |
| |
| // A stream is stalled by its send window being closed. |
| EVENT_TYPE(HTTP2_SESSION_STREAM_STALLED_BY_STREAM_SEND_WINDOW) |
| |
| // Session is closing |
| // { |
| // "net_error" : <The error status of the closure>, |
| // "description": <The textual description for the closure>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_CLOSE) |
| |
| // Event when the creation of a stream is stalled because we're at |
| // the maximum number of concurrent streams. |
| // { |
| // |
| // "num_active_streams": <Number of active streams>, |
| // "num_created_streams": <Number of created streams>, |
| // "num_pushed_streams": <Number of pushed streams>, |
| // "max_concurrent_streams": <Maximum number of concurrent streams>, |
| // "url": <Request URL>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_STALLED_MAX_STREAMS) |
| |
| // Received an out-of-range value for initial window size in SETTINGS |
| // frame. |
| // { |
| // "initial_window_size" : <The initial window size>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_INITIAL_WINDOW_SIZE_OUT_OF_RANGE) |
| |
| // Updating streams send window size by the delta window size. |
| // { |
| // "delta_window_size" : <The delta window size>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_UPDATE_STREAMS_SEND_WINDOW_SIZE) |
| |
| // Sending a greased frame (a frame of reserved type) |
| // { |
| // "stream_id": <The stream ID for the window update>, |
| // "type" : <Frame type>, |
| // "flags" : <Frame flags>, |
| // "length" : <Frame payload length>, |
| // "priority" : <RequestPriority of the stream>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_SEND_GREASED_FRAME) |
| |
| // ------------------------------------------------------------------------ |
| // SpdySessionPool |
| // ------------------------------------------------------------------------ |
| |
| // This event indicates the pool is reusing an existing session |
| // { |
| // "source_dependency": <The session id>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION) |
| |
| // This event indicates the pool is reusing an existing session from an |
| // IP pooling match. |
| // { |
| // "source_dependency": <The session id>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL) |
| |
| // This event indicates the pool created a new session |
| // { |
| // "source_dependency": <The session id>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_POOL_CREATED_NEW_SESSION) |
| |
| // This event indicates that a SSL socket has been upgraded to an HTTP/2 |
| // session. |
| // { |
| // "source_dependency": <The session id>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET) |
| |
| // This event indicates that the session has been removed. |
| // { |
| // "source_dependency": <The session id>, |
| // } |
| EVENT_TYPE(HTTP2_SESSION_POOL_REMOVE_SESSION) |
| |
| // ------------------------------------------------------------------------ |
| // SpdyStream |
| // ------------------------------------------------------------------------ |
| |
| // The begin and end of an HTTP/2 STREAM. |
| EVENT_TYPE(HTTP2_STREAM) |
| |
| // A stream is unstalled by flow control. |
| EVENT_TYPE(HTTP2_STREAM_FLOW_CONTROL_UNSTALLED) |
| |
| // This event indicates that the send window has been updated for a stream. |
| // { |
| // "id": <The stream id>, |
| // "delta": <The window size delta>, |
| // "new_window": <The new window size>, |
| // } |
| EVENT_TYPE(HTTP2_STREAM_UPDATE_SEND_WINDOW) |
| |
| // This event indicates that the recv window has been updated for a stream. |
| // { |
| // "id": <The stream id>, |
| // "delta": <The window size delta>, |
| // "new_window": <The new window size>, |
| // } |
| EVENT_TYPE(HTTP2_STREAM_UPDATE_RECV_WINDOW) |
| |
| // This event indicates a stream error |
| // { |
| // "id": <The stream id>, |
| // "status": <The error status>, |
| // "description": <The textual description for the error>, |
| // } |
| EVENT_TYPE(HTTP2_STREAM_ERROR) |
| |
| // A PRIORITY update is sent to the server. |
| // { |
| // "stream_id": <The stream id>, |
| // "parent_stream_id": <The stream's new parent stream>, |
| // "weight": <The stream's new weight>, |
| // "exclusive": <Whether the new dependency is exclusive>, |
| // } |
| EVENT_TYPE(HTTP2_STREAM_SEND_PRIORITY) |
| |
| // ------------------------------------------------------------------------ |
| // SpdyProxyClientSocket |
| // ------------------------------------------------------------------------ |
| |
| EVENT_TYPE(HTTP2_PROXY_CLIENT_SESSION) |
| // Identifies the HTTP/2 session a source is using. |
| // { |
| // "source_dependency": <Source identifier for the underlying session>, |
| // } |
| |
| // ------------------------------------------------------------------------ |
| // QuicStreamFactory |
| // ------------------------------------------------------------------------ |
| |
| // This event is emitted whenever a platform notification is received that |
| // could possibly trigger connection migration. |
| // { |
| // "signal": <Type of the platform notification> |
| // } |
| EVENT_TYPE(QUIC_STREAM_FACTORY_PLATFORM_NOTIFICATION) |
| |
| // These events track QuicStreamFactory's handling of OnIPAddressChanged and |
| // whether QuicSessions are closed or marked as going away. |
| EVENT_TYPE(QUIC_STREAM_FACTORY_ON_IP_ADDRESS_CHANGED) |
| EVENT_TYPE(QUIC_STREAM_FACTORY_CLOSE_ALL_SESSIONS) |
| EVENT_TYPE(QUIC_STREAM_FACTORY_MARK_ALL_ACTIVE_SESSIONS_GOING_AWAY) |
| |
| // ------------------------------------------------------------------------ |
| // QuicStreamFactory::Job |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time taken to execute the QuicStreamFactory::Job. |
| // The event parameters are: |
| // { |
| // "host": <The origin hostname that the Job serves>, |
| // "port": <The origin port>, |
| // "privacy_mode": <The privacy mode of the Job>, |
| // "network_anonymization_key": <The NetworkAnonymizationKey of the Job>, |
| // } |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB) |
| |
| // Identifies the NetLogSource() for the HttpStreamFactory::Job that the Job was |
| // attached to. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the HttpStreamFactory::Job to |
| // which we were attached>, |
| // } |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB) |
| |
| // Measures the time taken to establish a QUIC connection. |
| // The event parameters are: |
| // { |
| // "require_confirmation": <True if we require handshake confirmation |
| // in the connection> |
| // } |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_CONNECT) |
| |
| // This event indicates that the connection on the default network has failed |
| // before the handshake completed and a new connection on the alternate network |
| // will be attempted soon. |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_RETRY_ON_ALTERNATE_NETWORK) |
| |
| // This event indicates that the stale host result is used to try connecting. |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_TRIED_ON_CONNECTION) |
| |
| // This event indicates that stale host was not used to try connecting. |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_NOT_USED_ON_CONNECTION) |
| |
| // This event indicates that the stale host doesn't match with fresh host. |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_RESOLUTION_NO_MATCH) |
| |
| // This event indicates that stale host matches with fresh resolution. |
| EVENT_TYPE(QUIC_STREAM_FACTORY_JOB_STALE_HOST_RESOLUTION_MATCHED) |
| |
| // ------------------------------------------------------------------------ |
| // quic::QuicSession |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a quic::QuicSession. |
| // { |
| // "host": <The origin hostname string>, |
| // "port": <The origin port>, |
| // "privacy_mode": <The privacy mode of the session>, |
| // "network_anonymization_key": <The NetworkAnonymizationKey of the |
| // session>, |
| // "require_confirmation": <True if the session will wait for a |
| // successful QUIC handshake before vending |
| // streams>, |
| // "cert_verify_flags": <The certificate verification flags for the |
| // session>, |
| // } |
| EVENT_TYPE(QUIC_SESSION) |
| |
| // Session is closing because of an error. |
| // { |
| // "net_error": <Net error code for the closure>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_CLOSE_ON_ERROR) |
| |
| // Session verification of a certificate from the server failed. |
| // { |
| // } |
| EVENT_TYPE(QUIC_SESSION_CERTIFICATE_VERIFY_FAILED) |
| |
| // Session verified a certificate from the server. |
| // { |
| // "subjects": <list of DNS names that the certificate is valid for>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_CERTIFICATE_VERIFIED) |
| |
| // Session received a QUIC packet. |
| // { |
| // "peer_address": <The ip:port of the peer>, |
| // "self_address": <The local ip:port which received the packet>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_PACKET_RECEIVED) |
| |
| // Session sent a QUIC packet. |
| // { |
| // "encryption_level": <The quic::EncryptionLevel of the packet>, |
| // "transmission_type": <The quic::TransmissionType of the packet>, |
| // "packet_sequence_number": <The packet's full 64-bit sequence number, |
| // as a base-10 string.>, |
| // "size": <The size of the packet in bytes> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PACKET_SENT) |
| |
| // Session retransmitted a QUIC packet. |
| // { |
| // "old_packet_sequence_number": <The old packet's full 64-bit sequence |
| // number, as a base-10 string.>, |
| // "new_packet_sequence_number": <The new packet's full 64-bit sequence |
| // number, as a base-10 string.>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_PACKET_RETRANSMITTED) |
| |
| // Session declared a QUIC packet lost. |
| // { |
| // "transmission_type": <The quic::TransmissionType of the packet>, |
| // "packet_number": <The packet's full 64-bit number as a base-10 string>, |
| // "detection_time": <The time at which the packet was declared lost> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PACKET_LOST) |
| |
| // Congestion control parameters have been configured for the session. |
| // { |
| // "congestion_control_type": <The name of the CC algorithm used>, |
| // "use_pacing": <The bool indicating if pacing is enabled>, |
| // "initial_congestion_window": <The size of the initial congestion window> |
| // } |
| EVENT_TYPE(QUIC_CONGESTION_CONTROL_CONFIGURED) |
| |
| // Session received a QUIC packet with a sequence number that had previously |
| // been received. |
| // { |
| // "packet_sequence_number": <The packet's full 64-bit sequence number> |
| // } |
| EVENT_TYPE(QUIC_SESSION_DUPLICATE_PACKET_RECEIVED) |
| |
| // Session received a QUIC packet header, which has not yet been authenticated. |
| // { |
| // "connection_id": <The 64-bit CONNECTION_ID for this connection, as a |
| // base-10 string>, |
| // "packet_number": <The packet's full 64-bit sequence number, |
| // as a base-10 string.>, |
| // "header_format": <The format of the header in string>, |
| // If the header_format is long header: |
| // "long_header_type": <log the long header type> |
| // If Google QUIC is used: |
| // "reset_flag": <True if the reset flag is set for this packet>, |
| // "version_flag": <True if the version flag is set for this packet> |
| // } |
| EVENT_TYPE(QUIC_SESSION_UNAUTHENTICATED_PACKET_HEADER_RECEIVED) |
| |
| // Session has authenticated a QUIC packet. |
| EVENT_TYPE(QUIC_SESSION_PACKET_AUTHENTICATED) |
| |
| // Session received a STREAM frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // "fin": <True if this is the final data set by the peer on this stream>, |
| // "offset": <Offset in the byte stream where this data starts>, |
| // "length": <Length of the data in this frame>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_STREAM_FRAME_RECEIVED) |
| |
| // Session sent a STREAM frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // "fin": <True if this is the final data set by the peer on this stream>, |
| // "offset": <Offset in the byte stream where this data starts>, |
| // "length": <Length of the data in this frame>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_STREAM_FRAME_SENT) |
| |
| // A stream frame is coalesced with an existing stream frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // "fin": <True if this is the final data set by the peer on this stream>, |
| // "offset": <Offset in the byte stream where this data starts>, |
| // "length": <Length of the data in this frame>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_STREAM_FRAME_COALESCED) |
| |
| // Session received an ACK frame. |
| // { |
| // "largest_observed": <The largest packet number of a packet the peer has |
| // received, a.k.a. Largest Acknowledged>, |
| // "smallest_observed": <The smallest packet number covered by this ACK>, |
| // "delta_time_largest_observed_us": <Time between when the largest |
| // packet number was received and the ACK sent, a.k.a. Ack Delay>, |
| // "missing_packets": <List of packet numbers of packets between |
| // smallest_observed and largest_observed which were not received>, |
| // "received_packet_times": <List of dictionaries containing |
| // "packet_number" and "received" timestamps (if enabled)>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_ACK_FRAME_RECEIVED) |
| |
| // Session sent an ACK frame. |
| // { |
| // "largest_observed": <The largest packet number of a packet we have |
| // received, a.k.a. Largest Acknowledged>, |
| // "smallest_observed": <The smallest packet number covered by this ACK>, |
| // "delta_time_largest_observed_us": <Time between when the largest |
| // packet number was received and the ACK sent, a.k.a. Ack Delay>, |
| // "missing_packets": <List of packet numbers of packets between |
| // smallest_observed and largest_observed which were not received>, |
| // "received_packet_times": <List of dictionaries containing |
| // "packet_number" and "received" timestamps (if enabled)>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_ACK_FRAME_SENT) |
| |
| // Session received a WINDOW_UPDATE frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // "byte_offset": <Byte offset in the stream>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED) |
| |
| // Session sent a WINDOW_UPDATE frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // "byte_offset": <Byte offset in the stream>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT) |
| |
| // Session received a BLOCKED frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_BLOCKED_FRAME_RECEIVED) |
| |
| // Session sent a BLOCKED frame. |
| // { |
| // "stream_id": <The id of the stream which this data is for>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_BLOCKED_FRAME_SENT) |
| |
| // Session received a GOAWAY frame. |
| // { |
| // "quic_error": <quic::QuicErrorCode in the frame>, |
| // "last_good_stream_id": <Last correctly received stream id by the server>, |
| // "reason_phrase": <Prose justifying go-away request>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_GOAWAY_FRAME_RECEIVED) |
| |
| // Session sent a GOAWAY frame. |
| // { |
| // "quic_error": <quic::QuicErrorCode in the frame>, |
| // "last_good_stream_id": <Last correctly received stream id by the server>, |
| // "reason_phrase": <Prose justifying go-away request>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_GOAWAY_FRAME_SENT) |
| |
| // Session received a PING frame. |
| EVENT_TYPE(QUIC_SESSION_PING_FRAME_RECEIVED) |
| |
| // Session sent a PING frame. |
| EVENT_TYPE(QUIC_SESSION_PING_FRAME_SENT) |
| |
| // Session sent an MTU discovery frame (PING on wire). |
| EVENT_TYPE(QUIC_SESSION_MTU_DISCOVERY_FRAME_SENT) |
| |
| // Session received a STOP_WAITING frame. |
| // { |
| // "sent_info": <Details of packet sent by the peer> |
| // { |
| // "least_unacked": <Lowest sequence number of a packet sent by the peer |
| // for which it has not received an ACK>, |
| // } |
| // } |
| EVENT_TYPE(QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED) |
| |
| // Session sent an STOP_WAITING frame. |
| // { |
| // "sent_info": <Details of packet sent by the peer> |
| // { |
| // "least_unacked": <Lowest sequence number of a packet sent by the peer |
| // for which it has not received an ACK>, |
| // } |
| // } |
| EVENT_TYPE(QUIC_SESSION_STOP_WAITING_FRAME_SENT) |
| |
| // Session received a RST_STREAM frame. |
| // { |
| // "offset": <Offset in the byte stream which triggered the reset>, |
| // "quic_rst_stream_error": <quic::QuicRstStreamErrorCode in the frame>, |
| // "stream_id": <The stream id which this frame refers to>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_RST_STREAM_FRAME_RECEIVED) |
| |
| // Session sent a RST_STREAM frame. |
| // { |
| // "offset": <Offset in the byte stream which triggered the reset>, |
| // "quic_rst_stream_error": <quic::QuicRstStreamErrorCode in the frame>, |
| // "stream_id": <The stream id which this frame refers to>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_RST_STREAM_FRAME_SENT) |
| |
| // Session received a CONNECTION_CLOSE frame. |
| // { |
| // "quic_error": <quic::QuicErrorCode in the frame>, |
| // "details": <Human readable description>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_CONNECTION_CLOSE_FRAME_RECEIVED) |
| |
| // Session received a CONNECTION_CLOSE frame. |
| // { |
| // "quic_error": <quic::QuicErrorCode in the frame>, |
| // "details": <Human readable description>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT) |
| |
| // Session received a public reset packet. |
| // { |
| // } |
| EVENT_TYPE(QUIC_SESSION_PUBLIC_RESET_PACKET_RECEIVED) |
| |
| // Session received a version negotiation packet. |
| // { |
| // "versions": <List of QUIC versions supported by the server>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_VERSION_NEGOTIATION_PACKET_RECEIVED) |
| |
| // Session successfully negotiated QUIC version number. |
| // { |
| // "version": <String of QUIC version negotiated with the server>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_VERSION_NEGOTIATED) |
| |
| // Session revived a QUIC packet packet via FEC. |
| // { |
| // "connection_id": <The 64-bit CONNECTION_ID for this connection, as a |
| // base-10 string>, |
| // "public_flags": <The public flags set for this packet>, |
| // "packet_sequence_number": <The packet's full 64-bit sequence number, |
| // as a base-10 string.>, |
| // "private_flags": <The private flags set for this packet>, |
| // "fec_group": <The FEC group of this packet>, |
| // } |
| EVENT_TYPE(QUIC_SESSION_PACKET_HEADER_REVIVED) |
| |
| // Session received a crypto handshake message. |
| // { |
| // "quic_crypto_handshake_message": <The human readable dump of the message |
| // contents> |
| // } |
| EVENT_TYPE(QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_RECEIVED) |
| |
| // Session sent a crypto handshake message. |
| // { |
| // "quic_crypto_handshake_message": <The human readable dump of the message |
| // contents> |
| // } |
| EVENT_TYPE(QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_SENT) |
| |
| // A QUIC connection received transport parameters. |
| // { |
| // "quic_transport_parameters": <Human readable view of the transport |
| // parameters> |
| // } |
| EVENT_TYPE(QUIC_SESSION_TRANSPORT_PARAMETERS_RECEIVED) |
| |
| // A QUIC connection sent transport parameters. |
| // { |
| // "quic_transport_parameters": <Human readable view of the transport |
| // parameters> |
| // } |
| EVENT_TYPE(QUIC_SESSION_TRANSPORT_PARAMETERS_SENT) |
| |
| // A QUIC connection resumed transport parameters for 0-RTT. |
| // { |
| // "quic_transport_parameters": <Human readable view of the transport |
| // parameters> |
| // } |
| EVENT_TYPE(QUIC_SESSION_TRANSPORT_PARAMETERS_RESUMED) |
| |
| // A WebTransport client is alive. |
| EVENT_TYPE(QUIC_SESSION_WEBTRANSPORT_CLIENT_ALIVE) |
| |
| // A WebTransport client state has changed. |
| // { |
| // "last_state": <The last client state> |
| // "next_state": <The next client state> |
| // "error": <Optionally, error codes and details when an error happened> |
| // } |
| EVENT_TYPE(QUIC_SESSION_WEBTRANSPORT_CLIENT_STATE_CHANGED) |
| |
| // A WebTransport session is ready. |
| // { |
| // "http_datagram_version": <Negotiated HTTP Datagram version>, |
| // "webtransport_http3_version": <Negotiated WebTransport over HTTP/3 |
| // version> |
| // } |
| EVENT_TYPE(QUIC_SESSION_WEBTRANSPORT_SESSION_READY) |
| |
| // QUIC with TLS gets 0-RTT rejected. |
| EVENT_TYPE(QUIC_SESSION_ZERO_RTT_REJECTED) |
| |
| // Records that the QUIC session received a default network change signal. |
| // { |
| // "new_default_network": <The new default network> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NETWORK_MADE_DEFAULT) |
| |
| // Records that the QUIC session received a network disconnected signal. |
| // { |
| // "disconnected_network": <The network which was disconnected> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NETWORK_DISCONNECTED) |
| |
| // Records that the QUIC session received a network connected signal. |
| // { |
| // "connected_network": <The network which was connected> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NETWORK_CONNECTED) |
| |
| // Session was closed, either remotely or by the peer. |
| // { |
| // "quic_error": <quic::QuicErrorCode which caused the connection to be |
| // closed>, |
| // "details": <The error details string in the connection close.>, |
| // "from_peer": <True if the peer closed the connection> |
| // } |
| EVENT_TYPE(QUIC_SESSION_CLOSED) |
| |
| // Records that QUIC connectivity probe finished on the following path: |
| // { |
| // "network": <ID of the network probed> |
| // "peer address:" <Peer address probed> |
| // "is_success:" <Whether the connectivity probe succeeded> |
| // } |
| EVENT_TYPE(QUIC_SESSION_CONNECTIVITY_PROBING_FINISHED) |
| |
| // Session sent a PATH_CHALLENGE frame. |
| // { |
| // "data": <The challenge data in base64 string> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PATH_CHALLENGE_FRAME_SENT) |
| |
| // Session received a PATH_CHALLENGE frame. |
| // { |
| // "data": <The challenge data in base64 string> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PATH_CHALLENGE_FRAME_RECEIVED) |
| |
| // Session sent a PATH_RESPONSE frame. |
| // { |
| // "data": <The response data in base64 string> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PATH_RESPONSE_FRAME_SENT) |
| |
| // Session received a PATH_RESPONSE frame. |
| // { |
| // "data": <The response data in base64 string> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PATH_RESPONSE_FRAME_RECEIVED) |
| |
| // Session sent a CRYPTO frame. |
| // { |
| // "encryption_level": <The quic::EncryptionLevel of the frame>, |
| // "data_length": <The length of the CRYPTO frame data>, |
| // "offset": <The offset of the CRYPTO frame> |
| // } |
| EVENT_TYPE(QUIC_SESSION_CRYPTO_FRAME_SENT) |
| |
| // Session received a CRYPTO frame. |
| // { |
| // "encryption_level": <The quic::EncryptionLevel of the frame>, |
| // "data_length": <The length of the CRYPTO frame data>, |
| // "offset": <The offset of the CRYPTO frame> |
| // } |
| EVENT_TYPE(QUIC_SESSION_CRYPTO_FRAME_RECEIVED) |
| |
| // Session sent a STOP_SENDING frame. |
| // { |
| // "stream_id": <The stream id>, |
| // "rsr_stream_error_code": <quic::QuicRstStreamErrorCode in the frame> |
| // } |
| EVENT_TYPE(QUIC_SESSION_STOP_SENDING_FRAME_SENT) |
| |
| // Session received a STOP_SENDING frame. |
| // { |
| // "stream_id": <The stream id>, |
| // "rsr_stream_error_code": <Tquic::QuicRstStreamErrorCode in the frame> |
| // } |
| EVENT_TYPE(QUIC_SESSION_STOP_SENDING_FRAME_RECEIVED) |
| |
| // Session sent a STREAMS_BLOCKED frame. |
| // { |
| // "stream_count": <The number of streams that the sender wishes to exceed> |
| // "unidirectional": <boolean to indicate if the frame is for unidirectional |
| // streams.> |
| // } |
| EVENT_TYPE(QUIC_SESSION_STREAMS_BLOCKED_FRAME_SENT) |
| |
| // Session received a STREAMS_BLOCKED frame. |
| // { |
| // "stream_count": <The number of streams that the sender wishes to exceed> |
| // "unidirectional": <boolean to indicate if the frame is for unidirectional |
| // streams.> |
| // } |
| EVENT_TYPE(QUIC_SESSION_STREAMS_BLOCKED_FRAME_RECEIVED) |
| |
| // Session sent a MAX_STREAMS frame. |
| // { |
| // "stream_count": <The number of streams that may be opened> |
| // "unidirectional": <boolean to indicate if the frame is for unidirectional |
| // streams.> |
| // } |
| EVENT_TYPE(QUIC_SESSION_MAX_STREAMS_FRAME_SENT) |
| |
| // Session received a MAX_STREAMS frame. |
| // { |
| // "stream_count": <The number of streams that may be opened> |
| // "unidirectional": <boolean to indicate if the frame is for unidirectional |
| // streams.> |
| // } |
| EVENT_TYPE(QUIC_SESSION_MAX_STREAMS_FRAME_RECEIVED) |
| |
| // Session sent a PADDING frame. |
| // { |
| // "num_padding_bytes": <The number of padding bytes> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PADDING_FRAME_SENT) |
| |
| // Session received a PADDING frame. |
| // { |
| // "num_padding_bytes": <The number of padding bytes> |
| // } |
| EVENT_TYPE(QUIC_SESSION_PADDING_FRAME_RECEIVED) |
| |
| // Session sent a NEW_CONNECITON_ID frame. |
| // { |
| // "connection_id": <The new connection id> |
| // "sequencer_number": <Connection id sequence number that specifies the |
| // order that connection ids must be used in.> |
| // "retire_prior_to": <retire prior to> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NEW_CONNECTION_ID_FRAME_SENT) |
| |
| // Session received a NEW_CONNECITON_ID frame. |
| // { |
| // "connection_id": <The new connection id> |
| // "sequence_number": <Connection id sequence number that specifies the |
| // order that connection ids must be used in.> |
| // "retire_prior_to": <retire prior to> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NEW_CONNECTION_ID_FRAME_RECEIVED) |
| |
| // Session sent a NEW_TOKEN frame. |
| // { |
| // "token": <String representation of the token> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NEW_TOKEN_FRAME_SENT) |
| |
| // Session received a NEW_TOKEN frame. |
| // { |
| // "token": <String representation of the token> |
| // } |
| EVENT_TYPE(QUIC_SESSION_NEW_TOKEN_FRAME_RECEIVED) |
| |
| // Session sent a RETIRE_CONNECTION_ID frame. |
| // { |
| // "sequence_number": <Connection id sequence number that specifies the |
| // order that connection ids must be used in.> |
| // } |
| EVENT_TYPE(QUIC_SESSION_RETIRE_CONNECTION_ID_FRAME_SENT) |
| |
| // Session received a RETIRE_CONNECTION_ID frame. |
| // { |
| // "sequence_number": <Connection id sequence number that specifies the |
| // order that connection ids must be used in.> |
| // } |
| EVENT_TYPE(QUIC_SESSION_RETIRE_CONNECTION_ID_FRAME_RECEIVED) |
| |
| // Session sent a MESSAGE frame. |
| // { |
| // "message_length": <the length of the message> |
| // } |
| EVENT_TYPE(QUIC_SESSION_MESSAGE_FRAME_SENT) |
| |
| // Session received a MESSAGE frame. |
| // { |
| // "message_length": <the length of the message> |
| // } |
| EVENT_TYPE(QUIC_SESSION_MESSAGE_FRAME_RECEIVED) |
| |
| // Session received a HANDSHAKE_DONE frame. |
| EVENT_TYPE(QUIC_SESSION_HANDSHAKE_DONE_FRAME_RECEIVED) |
| |
| // Session received an ACCEPT_CH frame |
| // { |
| // "origin": <the origin the accept_ch settings apply to> |
| // "accept_ch": <the raw ACCEPT_CH data> |
| // } |
| EVENT_TYPE(QUIC_ACCEPT_CH_FRAME_RECEIVED) |
| |
| // Session sent a coalesced QUIC packet. |
| // { |
| // "info": <coalesced packet info> |
| // } |
| EVENT_TYPE(QUIC_SESSION_COALESCED_PACKET_SENT) |
| |
| // Session buffered an undecryptable packet. |
| // { |
| // "encryption_level": <the encryption level of the packet> |
| // } |
| EVENT_TYPE(QUIC_SESSION_BUFFERED_UNDECRYPTABLE_PACKET) |
| |
| // Session dropped an undecryptable packet. |
| // { |
| // "encryption_level": <the encryption level of the packet> |
| // } |
| EVENT_TYPE(QUIC_SESSION_DROPPED_UNDECRYPTABLE_PACKET) |
| |
| // Session is attempting to process an undecryptable packet. |
| // { |
| // "encryption_level": <the encryption level of the packet> |
| // } |
| EVENT_TYPE(QUIC_SESSION_ATTEMPTING_TO_PROCESS_UNDECRYPTABLE_PACKET) |
| |
| // Session has updated to the next set of 1-RTT keys. |
| // { |
| // "reason": <the reason the key update was triggered> |
| // } |
| EVENT_TYPE(QUIC_SESSION_KEY_UPDATE) |
| |
| // ------------------------------------------------------------------------ |
| // QuicHttpStream |
| // ------------------------------------------------------------------------ |
| |
| // Identifies the NetLogSource() for the QuicSession that handled the stream. |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for session that was used>, |
| // } |
| EVENT_TYPE(HTTP_STREAM_REQUEST_BOUND_TO_QUIC_SESSION) |
| |
| // ------------------------------------------------------------------------ |
| // QuicChromiumClientStream |
| // ------------------------------------------------------------------------ |
| |
| // The stream is sending the request headers. |
| // { |
| // "headers": <The list of header:value pairs> |
| // } |
| EVENT_TYPE(QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS) |
| |
| // The stream has read a 103 Early Hints response headers. |
| // { |
| // "headers": <The list of header:value pairs> |
| // } |
| EVENT_TYPE(QUIC_CHROMIUM_CLIENT_STREAM_READ_EARLY_HINTS_RESPONSE_HEADERS) |
| |
| // The stream has read the response headers. |
| // { |
| // "headers": <The list of header:value pairs> |
| // } |
| EVENT_TYPE(QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS) |
| |
| // The stream has read the response trailers. |
| // { |
| // "headers": <The list of header:value pairs> |
| // } |
| EVENT_TYPE(QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_TRAILERS) |
| |
| // ------------------------------------------------------------------------ |
| // QuicConnectionMigration |
| // ------------------------------------------------------------------------ |
| // Records the QUIC connection migration mode. |
| // { |
| // "connection_migration_mode": <The connection migration mode> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_MODE) |
| |
| // Records that QUIC connection migration has been triggered. |
| // { |
| // "trigger": <The reason for the migration attempt> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_TRIGGERED) |
| |
| // Records a failed QUIC connection migration attempt of the session |
| // identified by connection_id. |
| // { |
| // "connection_id": <Connection ID of the session> |
| // "reason": <String of the failure reason> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_FAILURE) |
| |
| // Records a successful QUIC connection migration attempt of the session |
| // identified by connection_id. |
| // { |
| // "connection_id": <Connection ID of the session> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_SUCCESS) |
| |
| // Records that a QUIC connection migration attempt due to new network |
| // being connected. |
| // { |
| // "connected_network": <The network we will try to migrate to> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_ON_NETWORK_CONNECTED) |
| |
| // Records that a QUIC connection migration attempt due to new network |
| // being marked as default network. |
| // { |
| // "new_default_network": <The new default network> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_ON_NETWORK_MADE_DEFAULT) |
| |
| // Records that a QUIC connection migration attempt due to old network |
| // being disconnected. |
| // { |
| // "disconnected_network": <The network which was disconnected> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_ON_NETWORK_DISCONNECTED) |
| |
| // Records that a QUIC connection migration attempt due to encountering |
| // packet write error on the current network. |
| // { |
| // "network": <Current network where we encountered the write error> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_ON_WRITE_ERROR) |
| |
| // Records that no alternate networks were available after either the default |
| // network was or a we encountered a packet write error. |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_WAITING_FOR_NEW_NETWORK) |
| |
| // Records that a QUIC connection migration attempt due to path |
| // degrading on the current network. |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_ON_PATH_DEGRADING) |
| |
| // Records that a QUIC connection migration attempt due to efforts to |
| // migrate back to the default network. |
| // { |
| // "retry_count": <Number of attempts to migrate back so far> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_ON_MIGRATE_BACK) |
| |
| // Records a QUIC connection migration failure after probing. |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_FAILURE_AFTER_PROBING) |
| |
| // Records a QUIC connection migration success after probing. |
| // { |
| // "migrate_to_network": <The network the probe was successful for> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_SUCCESS_AFTER_PROBING) |
| |
| // Records a QUIC connection migration timeout while waiting for a new network. |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_FAILURE_WAITING_FOR_NETWORK) |
| |
| // Records that a new network was found before QUIC connection migration timed |
| // out. |
| // { |
| // "network": <The network that was found and we will try to migrate to> |
| // } |
| EVENT_TYPE(QUIC_CONNECTION_MIGRATION_SUCCESS_WAITING_FOR_NETWORK) |
| |
| // ------------------------------------------------------------------------ |
| // QuicConnectivityProbingManager |
| // ------------------------------------------------------------------------ |
| |
| // Records that QUIC connectivity probing manager starts probing for the |
| // following path: |
| // { |
| // "network": <ID of the network being probed> |
| // "peer_address": <Peer address being probed> |
| // "initial_timeout_ms": <Initial timeout in milliseconds> |
| // } |
| EVENT_TYPE(QUIC_CONNECTIVITY_PROBING_MANAGER_START_PROBING) |
| |
| // Records that QUIC connectivity probing manager cancels probing for the |
| // following path: |
| // { |
| // "network": <ID of the network being probed> |
| // "peer_address": <Peer address being probed> |
| // } |
| EVENT_TYPE(QUIC_CONNECTIVITY_PROBING_MANAGER_CANCEL_PROBING) |
| |
| // Records that QUIC connectivity probing manager sends a probe. |
| // { |
| // "retry_count": <Number of the trial to send probe> |
| // } |
| EVENT_TYPE(QUIC_CONNECTIVITY_PROBING_MANAGER_PROBE_SENT) |
| |
| // Records that QUIC connectivity probing manager receives a probe on the |
| // following path: |
| // { |
| // "network": <ID of the network being probed> |
| // "self_address": <Self address on the probed path> |
| // "peer_address": <Peer address on the probed path> |
| // } |
| EVENT_TYPE(QUIC_CONNECTIVITY_PROBING_MANAGER_PROBE_RECEIVED) |
| |
| // Records that QUIC connectivity probing manager receives STATLESS_RESET on the |
| // following path: |
| // { |
| // "network": <ID of the network being probed> |
| // "self_address": <Self address on the probed path> |
| // "peer_address": <Peer address on the probed path> |
| // } |
| EVENT_TYPE(QUIC_CONNECTIVITY_PROBING_MANAGER_STATELESS_RESET_RECEIVED) |
| |
| // ------------------------------------------------------------------------ |
| // QuicPortMigration |
| // ------------------------------------------------------------------------ |
| |
| // Records that QUIC port migration has been triggered. |
| EVENT_TYPE(QUIC_PORT_MIGRATION_TRIGGERED) |
| |
| // Records a failed QUIC port migration attempt of the session identified |
| // by connection_id. |
| // { |
| // "connection_id": <Connection ID of the session> |
| // "reason": <String of the failure reason> |
| // } |
| EVENT_TYPE(QUIC_PORT_MIGRATION_FAILURE) |
| |
| // Records a successful QUIC port migration attempt of the session |
| // identified by connection_id. |
| // { |
| // "connection_id": <Connection ID of the session> |
| // } |
| EVENT_TYPE(QUIC_PORT_MIGRATION_SUCCESS) |
| |
| // ------------------------------------------------------------------------ |
| // QuicServerPreferredAddress |
| // ------------------------------------------------------------------------ |
| |
| // Records that client has received server preferred address. |
| EVENT_TYPE(QUIC_ON_SERVER_PREFERRED_ADDRESS_AVAILABLE) |
| |
| // Records that client starts to validate received server preferred address. |
| EVENT_TYPE(QUIC_START_VALIDATING_SERVER_PREFERRED_ADDRESS) |
| |
| // Records client fails to migrate to server preferred address of the session |
| // identified by connection_id. |
| // { |
| // "connection_id": <Connection ID of the session> |
| // "reason": <String of the failure reason> |
| // } |
| EVENT_TYPE(QUIC_FAILED_TO_VALIDATE_SERVER_PREFERRED_ADDRESS) |
| |
| // Records client successfully migrates to server preferred address of the |
| // session identified by connection_id. |
| // { |
| // "connection_id": <Connection ID of the session> |
| // } |
| EVENT_TYPE(QUIC_SUCCESSFULLY_MIGRATED_TO_SERVER_PREFERRED_ADDRESS) |
| |
| // A UDP socket error occurred while trying to read a QUIC packet. |
| // The following parameters are attached to the event: |
| // { |
| // "net_error": <Integer code for the specific error type>, |
| // } |
| EVENT_TYPE(QUIC_READ_ERROR) |
| |
| // ------------------------------------------------------------------------ |
| // HttpStreamParser |
| // ------------------------------------------------------------------------ |
| |
| // Measures the time to read HTTP response headers from the server. |
| EVENT_TYPE(HTTP_STREAM_PARSER_READ_HEADERS) |
| |
| // ------------------------------------------------------------------------ |
| // SOCKS5ClientSocket |
| // ------------------------------------------------------------------------ |
| |
| // The time spent sending the "greeting" to the SOCKS server. |
| EVENT_TYPE(SOCKS5_GREET_WRITE) |
| |
| // The time spent waiting for the "greeting" response from the SOCKS server. |
| EVENT_TYPE(SOCKS5_GREET_READ) |
| |
| // The time spent sending the CONNECT request to the SOCKS server. |
| EVENT_TYPE(SOCKS5_HANDSHAKE_WRITE) |
| |
| // The time spent waiting for the response to the CONNECT request. |
| EVENT_TYPE(SOCKS5_HANDSHAKE_READ) |
| |
| // ------------------------------------------------------------------------ |
| // HTTP Authentication |
| // ------------------------------------------------------------------------ |
| // |
| // Structure of common GSSAPI / SSPI values. |
| // ----------------------------------------- |
| // For convenience some structured GSSAPI/SSPI values are serialized |
| // consistently across different events. They are explained below. |
| // |
| // ** GSSAPI Status: |
| // |
| // A major/minor status code returned by a GSSAPI function. The major status |
| // code indicates the GSSAPI level error, while the minor code provides a |
| // mechanism specific error code if a specific GSSAPI mechanism was involved in |
| // the error. |
| // |
| // The status value has the following structure: |
| // { |
| // "function": <name of GSSAPI function that returned the error> |
| // "major_status": { |
| // "status" : <status value as a number>, |
| // "message": [ |
| // <list of strings hopefully explaining what that number means> |
| // ] |
| // }, |
| // "minor_status": { |
| // "status" : <status value as a number>, |
| // "message": [ |
| // <list of strings hopefully explaining what that number means> |
| // ] |
| // } |
| // } |
| // |
| // ** OID: |
| // |
| // An ASN.1 OID that's used for GSSAPI is serialized thusly: |
| // { |
| // "oid": <symbolic name of OID if it is known> |
| // "length": <length in bytes of serialized OID>, |
| // "bytes": <serialized bytes of OID encoded via NetLogBinaryValue()> |
| // } |
| // |
| // ** GSS Display Name: |
| // |
| // A serialization of GSSAPI principal name to something that can be consumed by |
| // humans. If the encoding of the string is not UTF-8 (since there's no |
| // requirement that they use any specific encoding) the field is serialized |
| // using NetLogBinaryValue(). |
| // { |
| // "name" : <GSSAPI principal name> |
| // "type" : <OID indicating type of name. See OID above.> |
| // "error": <If the display name lookup operation failed, then this field |
| // contains the error in the form of a GSSAPI Status.> |
| // } |
| // |
| // ** GSSAPI Context Flags |
| // |
| // Bitmask indicating properties of the negotiated security context. Values may |
| // be only advisory if the "open" flag of the enclosing security context is |
| // True. I.e. flags are not final until the security context is closed. |
| // |
| // { |
| // "flags" : <Flags. See RFC 2744 Section 5.19 for meanings. Flag |
| // bitmasks can be found in RFC 2744 Appendix A.> |
| // "delegated" : <True if credentials were delegated to the target.> |
| // "mutual" : <True if mutual authentication was successful.> |
| // } |
| // |
| // ** GSSAPI Context Description |
| // |
| // Properties of the GSSAPI security context being negotiated or that was |
| // negotiated. |
| // |
| // { |
| // "source" : <GSS Display Name for the source of the authentication |
| // attempt. In practice this is always the user's identity.> |
| // "target" : <GSS Display Name for the target of the authentication |
| // attempt. This the target server or proxy service |
| // principal.> |
| // "open" : <Boolean indicating whether the context is |open|, which |
| // means that the handshake is still in progress. In |
| // particular, the flags, lifetime, and mechanism fields are |
| // not considered final until |open| is false. |
| // "lifetime" : <A decimal string indicating the lifetime in seconds of the |
| // authentication context. The identity as established by this |
| // handshake is only valid for this long since the time at |
| // which it was established.> |
| // "mechanism": <OID indicating inner authentication mechanism.> |
| // "flags" : <GSSAPI Context Flags.> |
| // } |
| // |
| // ** SSPI SECURITY_STATUS |
| // |
| // SSPI functions invoked during Negotiate authentication on Windows return |
| // SECURITY_STATUS values. These values are documented alongside the functions |
| // that return them. Of these //net uses AcquireCredentialsHandle, and |
| // InitializeSecurityContext. |
| // |
| // { |
| // "net_error" : <net::Error value corresponding to the |security_status| |
| // value.> |
| // "security_status": <The |SECURITY_STATUS| value indicating the result of |
| // the operation.> |
| // } |
| // |
| // ** SSPI Context Flags |
| // |
| // Bitmask indicating properties of the negotiated security context. Values may |
| // be only advisory if the |open| flag of the enclosing security context is |
| // True. I.e. flags are not final until the security context is closed. |
| // |
| // { |
| // "flags" : <Bitmask in hexadecimal. See documentation for |
| // QueryContextAttributes for a description of the flags.> |
| // "delegated" : <True if credentials were delegated to the target.> |
| // "mutual" : <True if mutual authentication was successful.> |
| // } |
| // |
| // ** SSPI Context Description |
| // |
| // Properties of the SSPI security context being negotiated or that was |
| // negotiated. |
| // |
| // { |
| // "source" : <Source security principal. I.e. the user's identity.> |
| // "target" : <Target server's security principal name.> |
| // "open" : <True if the handshake is complete. Does not imply success |
| // or failure.> |
| // "mechanism" : <SSPI security package name for the selected mechanism.> |
| // "flags" : <SSPI Context Flags.> |
| // } |
| |
| // Lifetime event for HttpAuthController. |
| // |
| // The BEGIN phase has the following parameters: |
| // { |
| // "target": <Either "proxy" or "server">, |
| // "url": <URL of authentication target> |
| // } |
| EVENT_TYPE(AUTH_CONTROLLER) |
| |
| // Records on the caller's NetLog to indicate the HttpAuthController that's |
| // servicing the request. |
| // { |
| // "source_dependency": <Source ID of HttpAuthController> |
| // } |
| EVENT_TYPE(AUTH_BOUND_TO_CONTROLLER) |
| |
| // Record the result of attempting to create a HttpAuthHandler. |
| // |
| // { |
| // "scheme": <scheme> |
| // "net_error": <Net Error. Only present in case of error.> |
| // "challenge": <challenge string, if NetLogCaptureIncludesSensitive> |
| // "origin": <the origin of the server or proxy which issued the challenge> |
| // "allows_default_credentials": <whether the default credentials may be |
| // used for the origin> |
| // } |
| EVENT_TYPE(AUTH_HANDLER_CREATE_RESULT) |
| |
| // Record the initialization of an HttpAuthHandler derivative. |
| // |
| // The END phase has the following parameters: |
| // { |
| // "succeeded": <bool indicating whether the initialization succeeded> |
| // "allows_default_credentials": whether the default credentials may be |
| // used for the `origin` passed into |
| // `InitFromChallenge`. |
| // } |
| EVENT_TYPE(AUTH_HANDLER_INIT) |
| |
| // Records the invocation and completion of a single token generation operation. |
| // |
| // The END phase has the following parameters: |
| // { |
| // "net_error": <Net Error. Only present in case of error.> |
| // } |
| EVENT_TYPE(AUTH_GENERATE_TOKEN) |
| |
| // Records the invocation and completion of HandleAuthChallenge operation. |
| // |
| // Parameters: |
| // { |
| // "authorization_result": <One of "accept", "reject", "stale", "invalid", |
| // "different_realm" depending on the outcome of |
| // the handling the challenge> |
| // } |
| EVENT_TYPE(AUTH_HANDLE_CHALLENGE) |
| |
| // An attempt was made to load an authentication library. |
| // |
| // If the request succeeded, the parameters are: |
| // { |
| // "library_name": <Name of library> |
| // } |
| // Otherwise, the parameters are: |
| // { |
| // "library_name": <Name of library> |
| // "load_error": <An error string> |
| // } |
| EVENT_TYPE(AUTH_LIBRARY_LOAD) |
| |
| // A required method was not found while attempting to load an authentication |
| // library. |
| // |
| // Parameters are: |
| // { |
| // "library_name": <Name of the library where the method lookup failed> |
| // "method": <Name of method that was not found> |
| // } |
| EVENT_TYPE(AUTH_LIBRARY_BIND_FAILED) |
| |
| // Construction of the GSSAPI service principal name. |
| // |
| // Parameters: |
| // { |
| // "spn": <Service principal name as a string> |
| // "status": <GSSAPI Status. See GSSAPI Status above. This is field is only |
| // logged if the operation failed.> |
| // } |
| EVENT_TYPE(AUTH_LIBRARY_IMPORT_NAME) |
| |
| // Invocation of SSPI AcquireCredentialsHandle. |
| // |
| // The END phase has the following parameters: |
| // { |
| // "domain": <Domain of user> |
| // "user" : <Username> |
| // "status": <SSPI SECURITY_STATUS value.> |
| // } |
| // |
| // Note that "domain" and "user" are only present if the authentication |
| // handshake is using explicit credentials. In the case of ambient credentials |
| // the user identity is not known until the handshake is complete. |
| EVENT_TYPE(AUTH_LIBRARY_ACQUIRE_CREDS) |
| |
| // Initialize security context. |
| // |
| // This operation involves invoking an external library which may perform disk, |
| // IPC, and network IO as a part of its work. |
| // |
| // On Windows, the BEGIN phase has the following parameters: |
| // { |
| // "spn": <Service Principle Name>, |
| // "context_flags": <Integer with bitfield value> |
| // } |
| // |
| // The END phase has the following parameters. |
| // |
| // On Posix platforms: |
| // { |
| // "context": <GSSAPI Context Description>, |
| // "status" : <GSSAPI Status if the operation failed> |
| // } |
| // |
| // On Windows: |
| // { |
| // "context": <SSPI Context Description> |
| // "status" : <SSPI SECURITY_STATUS> |
| // } |
| EVENT_TYPE(AUTH_LIBRARY_INIT_SEC_CTX) |
| |
| // The channel bindings generated for the connection. |
| // { |
| // "token": <Hex encoded RFC 5929 'tls-server-endpoint' channel binding |
| // token. Could be empty if one could not be generated (e.g. |
| // because the underlying channel was not TLS.)> |
| // } |
| EVENT_TYPE(AUTH_CHANNEL_BINDINGS) |
| |
| // ------------------------------------------------------------------------ |
| // Global events |
| // ------------------------------------------------------------------------ |
| // These are events which are not grouped by source id, as they have no |
| // context. |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that an |
| // active network adapter's IP address has changed. |
| EVENT_TYPE(NETWORK_IP_ADDRESSES_CHANGED) |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that an |
| // active network adapter's connectivity status has changed. |
| // { |
| // "new_connection_type": <Type of the new connection> |
| // } |
| EVENT_TYPE(NETWORK_CONNECTIVITY_CHANGED) |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that a change |
| // occurs to the host computer's hardware or software that affects the route |
| // network packets take to any network server. |
| // { |
| // "new_connection_type": <Type of the new connection> |
| // } |
| EVENT_TYPE(NETWORK_CHANGED) |
| |
| // This event is emitted whenever DnsClient receives a new DnsConfig or |
| // DnsConfigOverrides. |
| // { |
| // "nameservers": <List of name server IPs>, |
| // "search": <List of domain suffixes>, |
| // "num_hosts": <Number of entries in the HOSTS file>, |
| // <other>: <See DnsConfig> |
| // } |
| EVENT_TYPE(DNS_CONFIG_CHANGED) |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that a |
| // network has connected and network-specific information is available |
| // (i.e. the handles::NetworkHandle of the network is known). |
| // { |
| // "changed_network_handle": <Network handle> |
| // "changed_network_type": <Type of network> |
| // "default_active_network_handle": <Network handle of default network> |
| // "current_active_networks": <Mapping from network handle to network |
| // type, containing entries for all active |
| // networks.> |
| // } |
| EVENT_TYPE(SPECIFIC_NETWORK_CONNECTED) |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that a |
| // network has disconnected and network-specific information is available |
| // (i.e. the handles::NetworkHandle of the network is known). |
| // { |
| // "changed_network_handle": <Network handle> |
| // "changed_network_type": <Type of network> |
| // "default_active_network_handle": <Network handle of default network> |
| // "current_active_networks": <Mapping from network handle to network |
| // type, containing entries for all active |
| // networks.> |
| // } |
| EVENT_TYPE(SPECIFIC_NETWORK_DISCONNECTED) |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that a |
| // network is soon to disconnect and network-specific information is available |
| // (i.e. the handles::NetworkHandle of the network is known). |
| // { |
| // "changed_network_handle": <Network handle> |
| // "changed_network_type": <Type of network> |
| // "default_active_network_handle": <Network handle of default network> |
| // "current_active_networks": <Mapping from network handle to network |
| // type, containing entries for all active |
| // networks.> |
| // } |
| EVENT_TYPE(SPECIFIC_NETWORK_SOON_TO_DISCONNECT) |
| |
| // This event is emitted whenever NetworkChangeNotifier determines that a |
| // network has become the default and network-specific information is available |
| // (i.e. the handles::NetworkHandle of the network is known). |
| // { |
| // "changed_network_handle": <Network handle> |
| // "changed_network_type": <Type of network> |
| // "default_active_network_handle": <Network handle of default network> |
| // "current_active_networks": <Mapping from network handle to network |
| // type, containing entries for all active |
| // networks.> |
| // } |
| EVENT_TYPE(SPECIFIC_NETWORK_MADE_DEFAULT) |
| |
| // This event is emitted whenever CertDatabase determines that the certificate |
| // database has changed. |
| EVENT_TYPE(CERTIFICATE_DATABASE_TRUST_STORE_CHANGED) |
| EVENT_TYPE(CERTIFICATE_DATABASE_CLIENT_CERT_STORE_CHANGED) |
| |
| // This event is logged when a request to conditionally clear the cached client |
| // certificate for a specific host has been received. It contains the following |
| // parameters: |
| // { |
| // "host": <Serialized scheme/host/port of the request>, |
| // "certificates": <A list of PEM encoded certificates, the first one |
| // being the new client certificate and the remaining |
| // being intermediate certificates. May be an empty |
| // list if no client certificate should be cached.>, |
| // "is_cleared": <boolean>, |
| // } |
| EVENT_TYPE(CLEAR_CACHED_CLIENT_CERT) |
| |
| // ------------------------------------------------------------------------ |
| // Exponential back-off throttling events |
| // ------------------------------------------------------------------------ |
| |
| // Emitted when back-off is disabled for a given host, or the first time |
| // a localhost URL is used (back-off is always disabled for localhost). |
| // { |
| // "host": <The hostname back-off was disabled for> |
| // } |
| EVENT_TYPE(THROTTLING_DISABLED_FOR_HOST) |
| |
| // Emitted when a request is denied due to exponential back-off throttling. |
| // { |
| // "url": <URL that was being requested>, |
| // "num_failures": <Failure count for the URL>, |
| // "release_after_ms": <Number of milliseconds until URL will be unblocked> |
| // } |
| EVENT_TYPE(THROTTLING_REJECTED_REQUEST) |
| |
| // ------------------------------------------------------------------------ |
| // DnsTransaction |
| // ------------------------------------------------------------------------ |
| |
| // The start/end of a DnsTransaction. |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "hostname": <The hostname it is trying to resolve>, |
| // "query_type": <Type of the query>, |
| // } |
| // |
| // The END phase contains the following parameters: |
| // |
| // { |
| // "net_error": <The net error code for the failure, if any>, |
| // } |
| EVENT_TYPE(DNS_TRANSACTION) |
| |
| // The start/end of a DnsTransaction query for a fully-qualified domain name. |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "qname": <The fully-qualified domain name it is trying to resolve>, |
| // } |
| // |
| // The END phase contains the following parameters: |
| // |
| // { |
| // "net_error": <The net error code for the failure, if any>, |
| // } |
| EVENT_TYPE(DNS_TRANSACTION_QUERY) |
| |
| // This event is created when DnsTransaction creates a new UDP socket and |
| // tries to resolve the fully-qualified name. |
| // |
| // It has a single parameter: |
| // |
| // { |
| // "source_dependency": <Source id of the UDP socket created for the |
| // attempt>, |
| // } |
| EVENT_TYPE(DNS_TRANSACTION_ATTEMPT) |
| |
| // This event is created when DnsTransaction creates a new TCP socket and |
| // tries to resolve the fully-qualified name. |
| // |
| // It has a single parameter: |
| // |
| // { |
| // "source_dependency": <Source id of the TCP socket created for the |
| // attempt>, |
| // } |
| EVENT_TYPE(DNS_TRANSACTION_TCP_ATTEMPT) |
| |
| // This event is created when DnsTransaction creates a new DoH request and |
| // tries to resolve the fully-qualified name. |
| // |
| // It has a single parameter: |
| // |
| // { |
| // "source_dependency": <Source id of the DoH request created for the |
| // attempt>, |
| // } |
| EVENT_TYPE(DNS_TRANSACTION_HTTPS_ATTEMPT) |
| |
| // This event is created when DnsTransaction receives a matching response. |
| // |
| // It has the following parameters: |
| // |
| // { |
| // "rcode": <rcode in the received response>, |
| // "answer_count": <answer_count in the received response>, |
| // "additional_answer_count": <additional_answer_count in the received |
| // response>, |
| // "source_dependency": <Source id of the UDP socket that received the |
| // response>, |
| // "response_buffer": <Raw buffer of the received response>, |
| // } |
| EVENT_TYPE(DNS_TRANSACTION_RESPONSE) |
| |
| // The start/end of a DoH request. |
| // |
| // The BEGIN phase contains the following parameters: |
| // |
| // { |
| // "hostname": <The hostname it is trying to resolve>, |
| // "query_type": <Type of the query>, |
| // } |
| // |
| // The END phase contains the following parameters: |
| // |
| // { |
| // "net_error": <The net error code for the failure, if any>, |
| // } |
| EVENT_TYPE(DOH_URL_REQUEST) |
| |
| // ------------------------------------------------------------------------ |
| // CertVerifier |
| // ------------------------------------------------------------------------ |
| |
| // This event is created when we start a CertVerifier request. |
| EVENT_TYPE(CERT_VERIFIER_REQUEST) |
| |
| // This event is created when we start a CertVerifier job. |
| // The BEGIN phase event parameters are: |
| // { |
| // "certificates": <A list of PEM encoded certificates, the first one |
| // being the certificate to verify and the remaining |
| // being intermediate certificates to assist path |
| // building.> |
| // "ocsp_response": <Optionally, a PEM encoded stapled OCSP response.> |
| // "sct_list": <Optionally, a PEM encoded SignedCertificateTimestampList.> |
| // "host": <The hostname verification is being performed for.> |
| // "verifier_flags": <The CertVerifier::VerifyFlags.> |
| // } |
| // |
| // The END phase event parameters are: |
| // { |
| // "cert_status": <Bitmask of CERT_STATUS_* |
| // from net/base/cert_status_flags.h> |
| // "has_md2": <True if a certificate in the certificate chain is signed with |
| // a MD2 signature.> |
| // "has_md4": <True if a certificate in the certificate chain is signed with |
| // a MD4 signature.> |
| // "has_md5": <True if a certificate in the certificate chain is signed with |
| // a MD5 signature.> |
| // "is_issued_by_additional_trust_anchor": <True if the root CA used for |
| // this verification came from the |
| // list of additional trust |
| // anchors.> |
| // "is_issued_by_known_root": <True if we recognise the root CA as a |
| // standard root. If it isn't then it's |
| // probably the case that this certificate |
| // was generated by a MITM proxy whose root |
| // has been installed locally. This is |
| // meaningless if the certificate was not |
| // trusted.> |
| // "net_error": <net error code returned from the verification.> |
| // "public_key_hashes": <If the certificate was successfully verified then |
| // this contains the hashes, in several hash |
| // algorithms, of the SubjectPublicKeyInfos of the |
| // chain.> |
| // "verified_cert": <The certificate chain that was constructed |
| // during verification. Note that though the verified |
| // certificate will match the originally supplied |
| // certificate, the intermediate certificates stored |
| // within may be substantially different. In the event |
| // of a verification failure, this will contain the |
| // chain as supplied by the server. This may be NULL |
| // if running within the sandbox.> |
| // } |
| EVENT_TYPE(CERT_VERIFIER_JOB) |
| |
| // This event is created when a CertVerifier request attaches to a job. |
| // |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the job we are bound to>, |
| // } |
| EVENT_TYPE(CERT_VERIFIER_REQUEST_BOUND_TO_JOB) |
| |
| // This event is created when a CertVerifier task is about to be posted. |
| EVENT_TYPE(CERT_VERIFIER_TASK) |
| |
| // This event is created when a CertVerifier task is created for a job. |
| // |
| // The event parameters are: |
| // { |
| // "source_dependency": <Source identifier for the job we are bound to>, |
| // } |
| EVENT_TYPE(CERT_VERIFIER_TASK_BOUND) |
| |
| // This event is created when CertVerifyProc is verifying a certificate. |
| // The BEGIN phase event parameters are: |
| // { |
| // "additional_trust_anchors": <Optionally, a list of PEM encoded |
| // certificates to be used as trust anchors |
| // in addition to the trust store.> |
| // "certificates": <A list of PEM encoded certificates, the first one |
| // being the certificate to verify and the remaining |
| // being intermediate certificates to assist path |
| // building.> |
| // "crlset_sequence": <Sequence number of the CRLSet.> |
| // "crlset_is_expired": <Boolean indicating whether the CRLSet is considered |
| // expired.> |
| // "ocsp_response": <Optionally, a PEM encoded stapled OCSP response.> |
| // "sct_list": <Optionally, a PEM encoded SignedCertificateTimestampList.> |
| // "host": <The hostname verification is being performed for.> |
| // "verify_flags": <The CertVerifyProc::VerifyFlags.> |
| // } |
| // |
| // The END phase event parameters are: |
| // { |
| // "cert_status": <Bitmask of CERT_STATUS_* |
| // from net/base/cert_status_flags.h> |
| // "has_md2": <True if a certificate in the certificate chain is signed with |
| // a MD2 signature.> |
| // "has_md4": <True if a certificate in the certificate chain is signed with |
| // a MD4 signature.> |
| // "has_md5": <True if a certificate in the certificate chain is signed with |
| // a MD5 signature.> |
| // "is_issued_by_additional_trust_anchor": <True if the root CA used for |
| // this verification came from the |
| // list of additional trust |
| // anchors.> |
| // "is_issued_by_known_root": <True if we recognise the root CA as a |
| // standard root. If it isn't then it's |
| // probably the case that this certificate |
| // was generated by a MITM proxy whose root |
| // has been installed locally. This is |
| // meaningless if the certificate was not |
| // trusted.> |
| // "net_error": <net error code returned from the verification.> |
| // "public_key_hashes": <If the certificate was successfully verified then |
| // this contains the hashes, in several hash |
| // algorithms, of the SubjectPublicKeyInfos of the |
| // chain.> |
| // "verified_cert": <The certificate chain that was constructed |
| // during verification. Note that though the verified |
| // certificate will match the originally supplied |
| // certificate, the intermediate certificates stored |
| // within may be substantially different. In the event |
| // of a verification failure, this will contain the |
| // chain as supplied by the server. This may be NULL |
| // if running within the sandbox.> |
| // } |
| EVENT_TYPE(CERT_VERIFY_PROC) |
| |
| // This event is created for the target cert passed into CertVerifyProcBulitin. |
| // The event parameters are: |
| // { |
| // "certificate": <The PEM encoded certificate.> |
| // "errors": <Optionally, a string describing any errors or warnings |
| // encountered while parsing the certificate.> |
| // } |
| EVENT_TYPE(CERT_VERIFY_PROC_TARGET_CERT) |
| |
| // This event is created for each additional certificate passed into |
| // CertVerifyProcBuiltin. |
| // The parameters are the same as for CERT_VERIFY_PROC_TARGET_CERT. |
| EVENT_TYPE(CERT_VERIFY_PROC_INPUT_CERT) |
| |
| // This event is created to log the Chrome Root Store version used |
| // by CertVerifyProcBuiltin. |
| // The event parameters are: |
| // { |
| // "version_major": <The major version of the Chrome Root Store> |
| // } |
| EVENT_TYPE(CERT_VERIFY_PROC_CHROME_ROOT_STORE_VERSION) |
| |
| // This event is created for each additional trust anchor passed into |
| // CertVerifyProcBuiltin. |
| // The parameters are the same as for CERT_VERIFY_PROC_TARGET_CERT. |
| EVENT_TYPE(CERT_VERIFY_PROC_ADDITIONAL_TRUST_ANCHOR) |
| |
| // This event is created for each path building attempt performed by |
| // CertVerifyProcBuiltin. |
| // The BEGIN phase contains the following information: |
| // { |
| // "digest_policy": <Specifies which digest methods are accepted in this |
| // attempt.> |
| // "is_ev_attempt": <True if this is an EV verification attempt.> |
| // } |
| // |
| // The END phase contains the following information: |
| // { |
| // "best_result_index": <Index of the best path that was found.> |
| // "has_valid_path": <True if one of the paths found was valid and |
| // trusted.> |
| // "exceeded_iteration_limit": <True if the iteration limit was exceeded |
| // during path building.> |
| // "exceeded_deadline": <True if the time limit was exceeded during path |
| // building.> |
| // } |
| EVENT_TYPE(CERT_VERIFY_PROC_PATH_BUILD_ATTEMPT) |
| |
| // This event is created for each path built during a |
| // CERT_VERIFY_PROC_PATH_BUILD_ATTEMPT. |
| // |
| // The event parameters are: |
| // { |
| // "certificates": <The certificate chain that was built.> |
| // "is_valid": <True if the chain is valid and trusted.> |
| // "last_cert_trust": <The trust setting found for the last cert in |
| // the chain.> |
| // "errors": <Optionally, a string describing any errors or warnings |
| // encountered while building or verifying the path.> |
| // } |
| EVENT_TYPE(CERT_VERIFY_PROC_PATH_BUILT) |
| |
| // ----------------------------------------------------------------------------- |
| // FTP events. |
| // ----------------------------------------------------------------------------- |
| |
| // This event is created when an FTP command is sent. It contains following |
| // parameters: |
| // { |
| // "command": <String - the command sent to remote server> |
| // } |
| EVENT_TYPE(FTP_COMMAND_SENT) |
| |
| // This event is created when FTP control connection is made. It contains |
| // following parameters: |
| // { |
| // "source_dependency": <id of log for control connection socket> |
| // } |
| EVENT_TYPE(FTP_CONTROL_CONNECTION) |
| |
| // This event is created when FTP data connection is made. It contains |
| // following parameters: |
| // { |
| // "source_dependency": <id of log for data connection socket> |
| // } |
| EVENT_TYPE(FTP_DATA_CONNECTION) |
| |
| // This event is created when FTP control connection response is processed. |
| // It contains following parameters: |
| // { |
| // "lines": <list of strings - each representing a line of the response> |
| // "status_code": <numeric status code of the response> |
| // } |
| EVENT_TYPE(FTP_CONTROL_RESPONSE) |
| |
| // ----------------------------------------------------------------------------- |
| // Simple Cache events. |
| // ----------------------------------------------------------------------------- |
| |
| // This event lasts the lifetime of a Simple Cache entry. |
| // It contains the following parameter: |
| // { |
| // "entry_hash": <hash of the entry, formatted as a hex string> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY) |
| |
| // This event is created when the entry's key is set. |
| // It contains the following parameter: |
| // { |
| // "key": <key of the entry> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_SET_KEY) |
| |
| // This event is created when OpenEntry is called. It has no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_OPEN_CALL) |
| |
| // This event is created when the Simple Cache actually begins opening the |
| // cache entry. It has no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_OPEN_BEGIN) |
| |
| // This event is created when the Simple Cache finishes the OpenEntry call. |
| // It contains the following parameter: |
| // { |
| // "net_error": <net error code returned from the call> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_OPEN_END) |
| |
| // This event is created when CreateEntry is called. It has no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CREATE_CALL) |
| |
| // This event is created when the Simple Cache optimistically returns a result |
| // from a CreateEntry call before it performs the create operation. |
| // It contains the following parameter: |
| // { |
| // "net_error": <net error code returned from the call> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CREATE_OPTIMISTIC) |
| |
| // This event is created when the Simple Cache actually begins creating the |
| // cache entry. It has no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CREATE_BEGIN) |
| |
| // This event is created when the Simple Cache finishes the CreateEntry call. |
| // It contains the following parameter: |
| // { |
| // "net_error": <net error code returned from the call> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CREATE_END) |
| |
| // This event is created when OpenOrCreateEntry is called. It has no |
| // parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_OPEN_OR_CREATE_CALL) |
| |
| // This event is created when the Simple Cache actually begins open/create of |
| // the cache entry. It has no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_OPEN_OR_CREATE_BEGIN) |
| |
| // This event is created when the Simple Cache finishes the OpenOrCreateEntry |
| // call. It contains the following parameter: |
| // { |
| // "net_error": <net error code returned from the call> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_OPEN_OR_CREATE_END) |
| |
| // This event is created when ReadData is called. |
| // It contains the following parameters: |
| // { |
| // "index": <Index being read/written>, |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_READ_CALL) |
| |
| // This event is created when the Simple Cache actually begins reading data |
| // from the cache entry. |
| // It contains the following parameters: |
| // { |
| // "index": <Index being read/written>, |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_READ_BEGIN) |
| |
| // This event is created when the Simple Cache finishes a ReadData call. |
| // It contains the following parameters: |
| // { |
| // "bytes_copied": <Number of bytes copied. Not present on error>, |
| // "net_error": <Network error code. Only present on error>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_READ_END) |
| |
| // This event is created when the Simple Cache begins to verify the checksum of |
| // cached data it has just read. It occurs before READ_END, and contains no |
| // parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CHECKSUM_BEGIN) |
| |
| // This event is created when the Simple Cache finishes verifying the checksum |
| // of cached data. It occurs after CHECKSUM_BEGIN but before READ_END, and |
| // contains one parameter: |
| // { |
| // "net_error": <net error code returned from the internal checksum call> |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CHECKSUM_END) |
| |
| // This event is created when WriteData is called. |
| // It contains the following parameters: |
| // { |
| // "index": <Index being read/written>, |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // "truncate": <If present for a write, the truncate flag is set to true. |
| // Not present in reads or writes where it is false>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_CALL) |
| |
| // This event is created when the Simple Cache optimistically returns a result |
| // from a WriteData call before it performs the write operation. |
| // It contains the following parameters: |
| // { |
| // "bytes_copied": <Number of bytes copied. Not present on error>, |
| // "net_error": <Network error code. Only present on error>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_OPTIMISTIC) |
| |
| // This event is created when the Simple Cache actually begins writing data to |
| // the cache entry. |
| // It contains the following parameters: |
| // { |
| // "index": <Index being read/written>, |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // "truncate": <If present for a write, the truncate flag is set to true. |
| // Not present in reads or writes where it is false>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_BEGIN) |
| |
| // This event is created when the Simple Cache finishes a WriteData call. |
| // It contains the following parameters: |
| // { |
| // "bytes_copied": <Number of bytes copied. Not present on error>, |
| // "net_error": <Network error code. Only present on error>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_END) |
| |
| // This event is created when ReadSparseData is called. |
| // It contains the following parameters: |
| // { |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // "truncate": <If present for a write, the truncate flag is set to true. |
| // Not present in reads or writes where it is false>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_READ_SPARSE_CALL) |
| |
| // This event is created when the Simple Cache actually begins reading sparse |
| // data from the cache entry. |
| // It contains the following parameters: |
| // { |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // "truncate": <If present for a write, the truncate flag is set to true. |
| // Not present in reads or writes where it is false>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_READ_SPARSE_BEGIN) |
| |
| // This event is created when the Simple Cache finishes a ReadSparseData call. |
| // It contains the following parameters: |
| // { |
| // "bytes_copied": <Number of bytes copied. Not present on error>, |
| // "net_error": <Network error code. Only present on error>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_READ_SPARSE_END) |
| |
| // This event is created when WriteSparseData is called. |
| // It contains the following parameters: |
| // { |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_SPARSE_CALL) |
| |
| // This event is created when the Simple Cache actually begins writing sparse |
| // data to the cache entry. |
| // It contains the following parameters: |
| // { |
| // "offset": <Offset being read/written>, |
| // "buf_len": <Length of buffer being read to/written from>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_SPARSE_BEGIN) |
| |
| // This event is created when the Simple Cache finishes a WriteSparseData call. |
| // It contains the following parameters: |
| // { |
| // "bytes_copied": <Number of bytes copied. Not present on error>, |
| // "net_error": <Network error code. Only present on error>, |
| // } |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_WRITE_SPARSE_END) |
| |
| // This event is created when DoomEntry is called. It contains no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_DOOM_CALL) |
| |
| // This event is created when the Simple Cache actually starts dooming a cache |
| // entry. It contains no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_DOOM_BEGIN) |
| |
| // This event is created when the Simple Cache finishes dooming an entry. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_DOOM_END) |
| |
| // This event is created when CloseEntry is called. It contains no parameters. |
| // A Close call may not result in CLOSE_BEGIN and CLOSE_END if there are still |
| // more references to the entry remaining. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CLOSE_CALL) |
| |
| // This event is created when the Simple Cache actually starts closing a cache |
| // entry. It contains no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CLOSE_BEGIN) |
| |
| // This event is created when the Simple Cache finishes a CloseEntry call. It |
| // contains no parameters. |
| EVENT_TYPE(SIMPLE_CACHE_ENTRY_CLOSE_END) |
| |
| // Marks start of UploadDataStream that is logged on initialization. |
| // The END phase contains the following parameters: |
| // { |
| // "net_error": <Result of the initialization step>, |
| // "total_size": <Shows total content length>, |
| // "is_chunked": <Shows whether data is chunked or not> |
| // } |
| EVENT_TYPE(UPLOAD_DATA_STREAM_INIT) |
| |
| // The start/end of UploadDataStream::Read method. |
| // |
| // The BEGIN phase contains the following information: |
| // { |
| // "current_position": <Shows current read position>, |
| // } |
| // |
| // The END phase contains the following information: |
| // { |
| // "result": <Result of reading. Result > 0 is bytes read. Result == 0 means |
| // the end of file. Result < 0 means an error.> |
| // } |
| EVENT_TYPE(UPLOAD_DATA_STREAM_READ) |
| |
| // ----------------------------------------------------------------------------- |
| // ResourceScheduler related events |
| // ----------------------------------------------------------------------------- |
| |
| // The ResourceScheduler has started a previously blocked request. Parameters: |
| // { |
| // "trigger": <Trigger for evaluation that caused request start> |
| // } |
| EVENT_TYPE(RESOURCE_SCHEDULER_REQUEST_STARTED) |
| |
| // ----------------------------------------------------------------------------- |
| // Auxiliary network service in-memory HTTP cache related events |
| // ----------------------------------------------------------------------------- |
| |
| // These event are emitted when HTTP response headers are served from the |
| // in-memory cache. |
| // The following parameters are attached: |
| // { |
| // "headers": <The list of header:value pairs>, |
| // } |
| EVENT_TYPE(IN_MEMORY_CACHE_READ_REQUEST_HEADERS) |
| EVENT_TYPE(IN_MEMORY_CACHE_READ_RESPONSE_HEADERS) |
| |
| // This event is emitted when response content are read from the in-memory |
| // cache. |
| // The following parameters are attached: |
| // { |
| // "byte_count": <Number of bytes that were just sent>, |
| // "bytes": <The exact bytes sent, Base64 encoded>, |
| // } |
| EVENT_TYPE(IN_MEMORY_CACHE_BYTES_READ) |
| |
| // ----------------------------------------------------------------------------- |
| // Network Quality Estimator related events |
| // ----------------------------------------------------------------------------- |
| |
| // This event is emitted whenever NetworkQualityEstimator determines that the |
| // quality of the network has changed. |
| // parameters: |
| // { |
| // "http_rtt": <Current estimate of the HTTP RTT>, |
| // "transport_rtt": <Current estimate of the transport RTT>, |
| // "downstream_throughput": <Current estimate of the downstream throughput>, |
| // "effective_connection_type": <Current estimate of the effective connection |
| // type>, |
| // } |
| EVENT_TYPE(NETWORK_QUALITY_CHANGED) |
| |
| // ----------------------------------------------------------------------------- |
| // Http Server Properties Manager related events |
| // ----------------------------------------------------------------------------- |
| |
| // This event is emitted when HttpServerPropertiesManager initialization starts |
| // and finishes. |
| EVENT_TYPE(HTTP_SERVER_PROPERTIES_INITIALIZATION) |
| |
| // This event is emitted when HttpServerPropertiesManager is updating in-memory |
| // version of HttpServerProperties from the serialized version from perfs/disk. |
| // parameters: |
| // { |
| // "servers": <List of servers and their protocol usage information>, |
| // "supports_quic": <Local IP addresses that used QUIC>, |
| // "version": <The version number>, |
| // } |
| EVENT_TYPE(HTTP_SERVER_PROPERTIES_UPDATE_CACHE) |
| |
| // This event is emitted when HttpServerPropertiesManager is persisting |
| // in-memory version of HttpServerProperties to prefs/disk. |
| // parameters: |
| // { |
| // "servers": <List of servers and their protocol usage information>, |
| // "supports_quic": <Local IP addresses that used QUIC>, |
| // "version": <The version number>, |
| // } |
| EVENT_TYPE(HTTP_SERVER_PROPERTIES_UPDATE_PREFS) |
| |
| // ----------------------------------------------------------------------------- |
| // HostCachePersistenceManager related events |
| // ----------------------------------------------------------------------------- |
| |
| // The start/end of getting the persisted HostCache value and restoring it. |
| // The END phase contains the following parameters: |
| // { |
| // "success": <Whether the persisted HostCache was restored successfully>, |
| // } |
| EVENT_TYPE(HOST_CACHE_PREF_READ) |
| |
| // This event is created when the HostCachePersistenceManager writes the cache |
| // contents to prefs. |
| EVENT_TYPE(HOST_CACHE_PREF_WRITE) |
| |
| // This event is created when the HostCachePersistenceManager starts the timer |
| // for writing a cache change to prefs. |
| EVENT_TYPE(HOST_CACHE_PERSISTENCE_START_TIMER) |
| |
| // ----------------------------------------------------------------------------- |
| // DHCP-based WPAD (Windows) |
| // ----------------------------------------------------------------------------- |
| |
| // The start/end of running DHCP based WPAD. |
| // |
| // The start event contains no parameters, whereas the END event describes |
| // which of the "adapter fetchers" was used: |
| // { |
| // "fetcher_index": <Index of the fetcher that "won" the race, or -1 if no |
| // fetcher won>, |
| // "net_error": <The network error code for the overall result of DHCP |
| // based auto-discovery>, |
| // } |
| EVENT_TYPE(WPAD_DHCP_WIN_FETCH) |
| |
| // The start/end of getting the list of network adapters. |
| // |
| // The END event describes all the adapters that were enumerated, as well |
| // as how long it took to do the various thread-hops (from origin to worker |
| // thread, and then worker thread back to origin thread): |
| // { |
| // "adapters": <List describing each adapter (its name, flags, and |
| // status)>, |
| // "origin_to_worker_thread_hop_dt": <The time in milliseconds it took |
| // for the worker thread task to get |
| // scheduled>, |
| // "worker_to_origin_thread_hop_dt": <The time in milliseconds it took |
| // for the reply task from worker |
| // thread to get scheduled>, |
| // "worker_dt": <The time in milliseconds it took to enumerate network |
| // adapters on the worker thread>, |
| // "error": <The result code returned by iphlpapi!GetAdaptersAddresses> |
| // } |
| EVENT_TYPE(WPAD_DHCP_WIN_GET_ADAPTERS) |
| |
| // This event logs when one of the "adapter fetchers" completed. (Fetchers |
| // may not complete in the order that they were started): |
| // { |
| // "fetcher_index": <Index of the fetcher that completed>, |
| // "net_error": <The network error code returned by the fetcher>, |
| // } |
| EVENT_TYPE(WPAD_DHCP_WIN_ON_FETCHER_DONE) |
| |
| // This event is logged when a timer is started to timeout remaining |
| // adapter fetchers. The event has no parameters. |
| EVENT_TYPE(WPAD_DHCP_WIN_START_WAIT_TIMER) |
| |
| // This event is emitted if the wait timer for remaining fetchers fires. It |
| // has no parameters. |
| EVENT_TYPE(WPAD_DHCP_WIN_ON_WAIT_TIMER) |
| |
| // ----------------------------------------------------------------------------- |
| // CookieStore related events |
| // ----------------------------------------------------------------------------- |
| |
| // Event emitted on store creation/deletion |
| // { |
| // "persistent_store": <Whether there is an attached persistent store>, |
| // } |
| EVENT_TYPE(COOKIE_STORE_ALIVE) |
| |
| // Event emitted on cookie addition |
| // { |
| // "name": <Name of the cookie added> |
| // "value": <Value of the cookie added> |
| // "domain": <Domain of the cookie added> |
| // "path": <Path of the cookie added> |
| // "is_persistent": <Whether or not the cookie is persistent> |
| // "sync_requested": <Whether sync to the backing store was requested> |
| // } |
| EVENT_TYPE(COOKIE_STORE_COOKIE_ADDED) |
| |
| // Event emitted on cookie deletion |
| // { |
| // "name": <Name of the cookie added> |
| // "value": <Value of the cookie added> |
| // "domain": <Domain of the cookie added> |
| // "path": <Path of the cookie added> |
| // "deletion_cause": <Reason the cookie was deleted> |
| // "httponly": <httponly field of the cookie> |
| // "secure": <If the cookie is a secure cookie> |
| // "priority": <priority of the cookie> |
| // "samesite": <SameSite setting for the cookie> |
| // "is_persistent": <Whether or not the cookie is persistent> |
| // "sync_requested": <Whether sync to the backing store was requested> |
| // } |
| EVENT_TYPE(COOKIE_STORE_COOKIE_DELETED) |
| |
| // Event emitted on rejection of a cookie addition because of a conflict |
| // with a secure cookie that would have been deleted. |
| // { |
| // "name": <Name of the cookies> |
| // "domain": <Domain of the cookies> |
| // "oldpath": <Path of the cookie that would have been deleted> |
| // "newpath": <Path of the cookie that would have been added> |
| // "oldvalue": <Value of the cookie that would have been deleted> |
| // "newvalue": <Value of the cookie that would have been added> |
| // } |
| EVENT_TYPE(COOKIE_STORE_COOKIE_REJECTED_SECURE) |
| |
| // Event emitted on rejection of a cookie addition because of a conflict |
| // with an httponly cookie. |
| // { |
| // "name": <Name of the cookies> |
| // "domain": <Domain of the cookies> |
| // "path": <Path of the cookies> |
| // "oldvalue": <Value of the cookie that would have been deleted> |
| // "newvalue": <Value of the cookie that would have been added> |
| // } |
| EVENT_TYPE(COOKIE_STORE_COOKIE_REJECTED_HTTPONLY) |
| |
| // Event emitted on preservation of a cookie that would have been |
| // overwritten, because cookie addition failed due to a conflict with a secure |
| // cookie. |
| // { |
| // "name": <Name of the cookies> |
| // "domain": <Domain of the preserved and new cookies> |
| // "path": <Path of the preserved and new cookies> |
| // "securecookiedomain": <Domain of the secure cookie causing preservation> |
| // "securecookiepath": <Path of the secure cookie causing preservation> |
| // "preservedvalue": <Value of the preserved cookie> |
| // "discardedvalue": <Value of the new cookie whose addition failed> |
| // } |
| EVENT_TYPE(COOKIE_STORE_COOKIE_PRESERVED_SKIPPED_SECURE) |
| |
| // Event emitted on setting store session persistence |
| // { |
| // "persistence" : <Session persistence setting for the store> |
| // } |
| EVENT_TYPE(COOKIE_STORE_SESSION_PERSISTENCE) |
| |
| // Event emitted when a particular origin is removed from the persistent |
| // store on shutdown. |
| // { |
| // "origin": <Origin being filtered> |
| // "is_https": <Secure status of origin> |
| // } |
| EVENT_TYPE(COOKIE_PERSISTENT_STORE_ORIGIN_FILTERED) |
| |
| // Event emitted when the persistent database load is started and completed. |
| // { |
| // } |
| EVENT_TYPE(COOKIE_PERSISTENT_STORE_LOAD) |
| |
| // Event emitted when load for a particular key is started. |
| // { |
| // "key": <Key to be loaded> |
| // } |
| EVENT_TYPE(COOKIE_PERSISTENT_STORE_KEY_LOAD_STARTED) |
| |
| // Event emitted when load for a particular key is completed. |
| // { |
| // "key": <Key to be loaded> |
| // } |
| EVENT_TYPE(COOKIE_PERSISTENT_STORE_KEY_LOAD_COMPLETED) |
| |
| // Event emitted when a persistent store has been closed. |
| // { |
| // "type": <Classname of persistent cookie store> |
| // } |
| EVENT_TYPE(COOKIE_PERSISTENT_STORE_CLOSED) |
| |
| // Event emitted when getting cookies is blocked by a NetworkDelegate. |
| // { |
| // } |
| EVENT_TYPE(COOKIE_GET_BLOCKED_BY_NETWORK_DELEGATE) |
| |
| // Event emitted when setting cookies is blocked by a NetworkDelegate. |
| // { |
| // } |
| EVENT_TYPE(COOKIE_SET_BLOCKED_BY_NETWORK_DELEGATE) |
| |
| // Event emitted when a cookie is received but not stored, or when a cookie is |
| // not sent to an associated domain. |
| // { |
| // "status": <Exclusion flags>, |
| // "name": <Name of the cookie>, |
| // "domain": <Domain of the cookie>, |
| // "path": <Path of the cookie>, |
| // "operation": <Operation, either "send" or "store"> |
| // } |
| EVENT_TYPE(COOKIE_INCLUSION_STATUS) |
| |
| // ----------------------------------------------------------------------------- |
| // HTTP/3 events. |
| // ----------------------------------------------------------------------------- |
| |
| // Event emitted when locally-initiated HTTP/3 control stream is created. |
| // { |
| // "stream_id": <The stream id of locally created control stream> |
| // } |
| EVENT_TYPE(HTTP3_LOCAL_CONTROL_STREAM_CREATED) |
| |
| // Event emitted when locally-initiated QPACK encoder stream is created. |
| // { |
| // "stream_id": <The stream id of locally created QPACK encoder stream> |
| // } |
| EVENT_TYPE(HTTP3_LOCAL_QPACK_ENCODER_STREAM_CREATED) |
| |
| // Event emitted when locally-initiated QPACK decoder stream is created. |
| // { |
| // "stream_id": <The stream id of locally created QPACK decoder stream> |
| // } |
| EVENT_TYPE(HTTP3_LOCAL_QPACK_DECODER_STREAM_CREATED) |
| |
| // Event emitted when peer created HTTP/3 control stream type is received. |
| // { |
| // "stream_id": <The stream id of peer created control stream> |
| // } |
| EVENT_TYPE(HTTP3_PEER_CONTROL_STREAM_CREATED) |
| |
| // Event emitted when peer created QPACK encoder stream type is received. |
| // { |
| // "stream_id": <The stream id of the peer created QPACK encoder stream> |
| // } |
| EVENT_TYPE(HTTP3_PEER_QPACK_ENCODER_STREAM_CREATED) |
| |
| // Event emitted when peer created QPACK decoder stream type is received. |
| // { |
| // "stream_id": <The stream id of the peer created QPACK decoder stream> |
| // } |
| EVENT_TYPE(HTTP3_PEER_QPACK_DECODER_STREAM_CREATED) |
| |
| // Event emitted when an HTTP/3 CANCEL_PUSH frame is received. |
| // { |
| // "push_id": <The push_id field of the CANCEL_PUSH frame> |
| // } |
| EVENT_TYPE(HTTP3_CANCEL_PUSH_RECEIVED) |
| |
| // Event emitted when SETTINGS frame is received. |
| // A list of settings will be logged by |
| // <setting identifier>: <setting value> |
| EVENT_TYPE(HTTP3_SETTINGS_RECEIVED) |
| |
| // Event emitted when an HTTP/3 GOAWAY frame is received. |
| // { |
| // "stream_id": <The stream_id field of the GOAWAY frame> |
| // } |
| EVENT_TYPE(HTTP3_GOAWAY_RECEIVED) |
| |
| // Event emitted when an HTTP/3 MAX_PUSH_ID frame is received. |
| // { |
| // "push_id": <The push_id field of the MAX_PUSH_ID frame> |
| // } |
| EVENT_TYPE(HTTP3_MAX_PUSH_ID_RECEIVED) |
| |
| // Event emitted when an HTTP/3 PRIORITY_UPDATE frame is received. |
| // { |
| // "type": <The prioritized element type field of the PRIORITY_UPDATE frame> |
| // "prioritized_element_id": <The prioritized_element_id field of the |
| // PRIORITY_UPDATE frame> |
| // "priority_field_value": <The priority_field_value field of the |
| // PRIORITY_UPDATE frame> |
| // } |
| EVENT_TYPE(HTTP3_PRIORITY_UPDATE_RECEIVED) |
| |
| // Event emitted when an HTTP/3 DATA frame header is received. |
| // { |
| // "stream_id": <The ID of the stream on which the DATA frame is received> |
| // "payload_length": <The length of DATA frame payload> |
| // } |
| EVENT_TYPE(HTTP3_DATA_FRAME_RECEIVED) |
| |
| // Event emitted when the receipt of an HTTP/3 HEADERS frame is complete. |
| // { |
| // "stream_id": <The ID of the stream on which the HEADERS frame is received> |
| // "payload_length": <The total number of payload bytes received> |
| // } |
| EVENT_TYPE(HTTP3_HEADERS_RECEIVED) |
| |
| // Event emitted when headers received in an HTTP/3 HEADERS frame are decoded. |
| // { |
| // "stream_id": <The ID of the stream on which the HEADERS frame had been |
| // received> |
| // "headers": <A dictionary of the decoded headers> |
| // } |
| EVENT_TYPE(HTTP3_HEADERS_DECODED) |
| |
| // Event emitted when the receipt of an HTTP/3 PUSH_PROMISE frame is complete. |
| // { |
| // "stream_id": <The ID of the stream on which the PUSH_PROMISE frame is |
| // received> |
| // "push_id": <The push_id field of the PUSH_PROMISE frame> |
| // } |
| EVENT_TYPE(HTTP3_PUSH_PROMISE_RECEIVED) |
| |
| // Event emitted when headers received in an HTTP/3 PUSH_PROMISE frame are |
| // decoded. |
| // { |
| // "stream_id": <The ID of the stream on which the PUSH_PROMISE frame had |
| // been received> |
| // "push_id": <The push_id field of the PUSH_PROMISE frame> |
| // "headers": <A dictionary of the decoded headers> |
| // } |
| EVENT_TYPE(HTTP3_PUSH_PROMISE_DECODED) |
| |
| // Event emitted when the frame header of an HTTP/3 frame of unknown type is |
| // received. |
| // { |
| // "stream_id": <The ID of the stream on which the frame is received> |
| // "frame_type": <The frame type> |
| // "payload_length": <The length of the frame payload> |
| // } |
| EVENT_TYPE(HTTP3_UNKNOWN_FRAME_RECEIVED) |
| |
| // Event emitted when an HTTP/3 SETTINGS frame is sent. |
| // A list of settings will be logged by |
| // <setting identifier>: <setting value> |
| EVENT_TYPE(HTTP3_SETTINGS_SENT) |
| |
| // Event emitted when an HTTP/3 SETTINGS frame is resumed for 0-RTT. |
| // A list of settings will be logged by |
| // <setting identifier>: <setting value> |
| EVENT_TYPE(HTTP3_SETTINGS_RESUMED) |
| |
| // Event emitted when an HTTP/3 GOAWAY frame is sent. |
| // { |
| // "stream_id": <The stream_id field of the GOAWAY frame> |
| // } |
| EVENT_TYPE(HTTP3_GOAWAY_SENT) |
| |
| // Event emitted when an HTTP/3 MAX_PUSH_ID frame is sent. |
| // { |
| // "push_id": <The push_id field of the MAX_PUSH_ID frame> |
| // } |
| EVENT_TYPE(HTTP3_MAX_PUSH_ID_SENT) |
| |
| // Event emitted when an HTTP/3 PRIORITY_UPDATE frame is sent. |
| // { |
| // "type": <The prioritized element type field of the PRIORITY_UPDATE frame> |
| // "prioritized_element_id": <The prioritized_element_id field of the |
| // PRIORITY_UPDATE frame> |
| // "priority_field_value": <The priority_field_value field of the |
| // PRIORITY_UPDATE frame> |
| // } |
| EVENT_TYPE(HTTP3_PRIORITY_UPDATE_SENT) |
| |
| // Event emitted when an HTTP/3 DATA frame is sent. |
| // { |
| // "stream_id": <The ID of the stream on which the frame is sent> |
| // "payload_length": <The total payload length of the frame> |
| // } |
| EVENT_TYPE(HTTP3_DATA_SENT) |
| |
| // Event emitted when an HTTP/3 HEADERS frame is sent. |
| // { |
| // "stream_id": <The ID of the stream on which the frame is sent> |
| // "headers": <A dictionary of the headers sent> |
| // } |
| EVENT_TYPE(HTTP3_HEADERS_SENT) |
| |
| // Event emitted when an HTTP/3 PUSH_PROMISE frame is sent. |
| // { |
| // "stream_id": <The ID of the stream on which the frame is sent> |
| // "push_id": <The push_id field of the PUSH_PROMISE frame> |
| // "headers": <A dictionary of the headers sent> |
| // } |
| EVENT_TYPE(HTTP3_PUSH_PROMISE_SENT) |
| |
| // ----------------------------------------------------------------------------- |
| // Trust Tokens-related events |
| // ----------------------------------------------------------------------------- |
| |
| // Event emitted when a request with an associated Trust Tokens operation |
| // reaches the net stack (TrustTokenRequestHelperFactory). |
| // |
| // The BEGIN event contains the operation type: |
| // { |
| // "Operation type (mojom.TrustTokenOperationType)": <The operation type> |
| // } |
| // |
| // The END event contains a human-readable explanation of whether creating a |
| // Trust Tokens helper (i.e., moving on to the bulk of the operation-specific |
| // logic) succeeded or failed: |
| // { |
| // "outcome": <human-readable explanation of the outcome> |
| // } |
| EVENT_TYPE(TRUST_TOKEN_OPERATION_REQUESTED) |
| |
| // For each of the BEGIN/FINALIZE event type pairs below: |
| // |
| // The BEGIN event type's BEGIN event is emitted when a request with an |
| // associated Trust Tokens operation starts the "Begin" (outbound) phase of the |
| // operation. Its END event contains a description of why the outbound phase of |
| // the operation succeeded or failed: |
| // { |
| // "outcome": <human-readable explanation of the outcome> |
| // } |
| // |
| // The FINALIZE event type is the analogue for the "Finalize" (inbound) phase of |
| // the operation. |
| // |
| // BEGIN_ISSUANCE's BEGIN event is the only event containing a dynamic parameter |
| // populated with data from an operation (rather than just a success-or-error |
| // description). On success, it contains the number of signed tokens that the |
| // issuance operation yielded. |
| // { |
| // "outcome": <human-readable explanation of the outcome>, |
| // "# tokens obtained": <number of tokens> |
| // } |
| EVENT_TYPE(TRUST_TOKEN_OPERATION_BEGIN_ISSUANCE) |
| EVENT_TYPE(TRUST_TOKEN_OPERATION_FINALIZE_ISSUANCE) |
| |
| EVENT_TYPE(TRUST_TOKEN_OPERATION_BEGIN_REDEMPTION) |
| EVENT_TYPE(TRUST_TOKEN_OPERATION_FINALIZE_REDEMPTION) |
| |
| EVENT_TYPE(TRUST_TOKEN_OPERATION_BEGIN_SIGNING) |
| |
| // ----------------------------------------------------------------------------- |
| // CORS preflight events |
| // ----------------------------------------------------------------------------- |
| |
| // The start/end of CORS preflight request. It corresponds with the lifetime of |
| // CorsURLLoader. |
| // |
| // The BEGIN phase contains the following parameters. |
| // See network.mojom.ResourceRequest for details. |
| // |
| // { |
| // "cors_preflight_policy" : <A policy to decide if CORS-preflight fetch |
| // should be performed>, |
| // "headers" : <The list of header:value pairs>, |
| // "is_revalidating": <Boolean indicating whether request is revalidating>, |
| // "method": <The method ("POST" or "GET" or "HEAD" etc...)>, |
| // "url": <The URL to create a request for> |
| // } |
| EVENT_TYPE(CORS_REQUEST) |
| |
| // This event is logged when CorsURLLoader judges if preflight request is |
| // required. If required, the reason of judgement is recorded next. |
| // It contains the following parameter: |
| // { |
| // "preflight_required": <Boolean indicating whether preflight request is |
| // required>, |
| // "preflight_required_reason": <The reason why preflight is required> |
| // } |
| EVENT_TYPE(CHECK_CORS_PREFLIGHT_REQUIRED) |
| |
| // This event is logged when PreflightController checks preflight cache. |
| // It contains the following parameter: |
| // { |
| // "status": <The result of cache checking. "hit-and-pass", |
| // "hit-and-fail", "miss" or "stale"> |
| // } |
| EVENT_TYPE(CHECK_CORS_PREFLIGHT_CACHE) |
| |
| // This event is logged when PreflightController gets CORS preflight result |
| // from preflight request. |
| // It contains the following parameter: |
| // { |
| // "access-control-allow-headers": <List of headers given in |
| // `Access-Control-Allow-Headers`>, |
| // "access-control-allow-methods": <List of methods given in |
| // `Access-Control-Allow-Methods`> |
| // } |
| EVENT_TYPE(CORS_PREFLIGHT_RESULT) |
| |
| // This event is logged when PreflightController detects a failed CORS |
| // preflight. |
| // |
| // It contains the following parameters: |
| // { |
| // "error: <A string representing the network error for the failure. |
| // "ERR_FAILED" for CORS errors.>, |
| // "cors-error": <Optional. An integer representing the more granular reason |
| // for the CORS error, if any. Values map to |
| // `network::mojom::CorsError`.>, |
| // "failed-parameter": <Optional, absent if `cors-error` is absent. A string |
| // representing the parameter that failed validation, |
| // e.g. a forbidden header.>, |
| // } |
| EVENT_TYPE(CORS_PREFLIGHT_ERROR) |
| |
| // This event identifies the NetLogSource() for a URLRequest of the preflight |
| // request. |
| EVENT_TYPE(CORS_PREFLIGHT_URL_REQUEST) |
| |
| // This event is logged when PreflightController gets CORS preflight result |
| // from preflight cache. |
| // The parameters are the same as for CORS_PREFLIGHT_RESULT. |
| EVENT_TYPE(CORS_PREFLIGHT_CACHED_RESULT) |
| |
| // ------------------------------------------------------------------------ |
| // Private Network Access |
| // ------------------------------------------------------------------------ |
| |
| // This event is logged when a new connection is checked against Private |
| // Network Access rules. |
| // |
| // It contains the following parameters: |
| // { |
| // "client_address_space": <the IP address space of the request client>, |
| // "resource_address_space": <the IP address space of the remote endpoint>, |
| // "result": <the result of the check>, |
| // } |
| // |
| // If the result is "unexpected-private-network", then the request is |
| // interrupted and a preflight request is retried, this time with PNA headers |
| // attached. If this second connection fails the check again, the request is |
| // failed. |
| EVENT_TYPE(PRIVATE_NETWORK_ACCESS_CHECK) |
| |
| // ------------------------------------------------------------------------ |
| // Initiator |
| // ------------------------------------------------------------------------ |
| |
| // This event is logged to indicate the initiator of the network event. |
| // The event contains the following parameters: |
| // { |
| // "source_dependency": <Source identifier for the attached event> |
| // } |
| EVENT_TYPE(CREATED_BY) |
| |
| // This event is logged when a URLRequestHttpJob's privacy mode is computed. It |
| // contains the following parameter: |
| // { |
| // "privacy_mode": <Privacy mode associated with the request>, |
| // } |
| EVENT_TYPE(COMPUTED_PRIVACY_MODE) |
| |
| // ------------------------------------------------------------------------ |
| // WebSocket |
| // ------------------------------------------------------------------------ |
| |
| // This event is logged when an error occurs during WebSocket handshake. It |
| // contains the following parameters: |
| // { |
| // "net_error": <The number showing network error type>, |
| // "message": <Failure message>, |
| // } |
| EVENT_TYPE(WEBSOCKET_UPGRADE_FAILURE) |
| |
| // This event is logged when the WebSocket read buffer size is changed. It |
| // contains the following parameters: |
| // { |
| // "read_buffer_size_in_bytes": <New read buffer size in bytes>, |
| // } |
| EVENT_TYPE(WEBSOCKET_READ_BUFFER_SIZE_CHANGED) |
| |
| // This event is logged to show the received frame header information. It |
| // contains the following parameters: |
| // { |
| // "final": <Whether it is the last fragment in a message>, |
| // "reserved1": <Whether any extension is defined>, |
| // "reserved2": <Whether any extension is defined>, |
| // "reserved3": <Whether any extension is defined>, |
| // "opcode": <Opcode in the frame header>, |
| // "masked": <Whether the message is encoded>, |
| // "payload_length": <Payload length in the frame header>, |
| // } |
| EVENT_TYPE(WEBSOCKET_RECV_FRAME_HEADER) |
| |
| // This event is logged to show the sent frame header information. It |
| // contains the following parameters: |
| // { |
| // "final": <Whether it is the last fragment in a message>, |
| // "reserved1": <Whether any extension is defined>, |
| // "reserved2": <Whether any extension is defined>, |
| // "reserved3": <Whether any extension is defined>, |
| // "opcode": <Opcode in the frame header>, |
| // "masked": <Whether the message is encoded>, |
| // "payload_length": <Payload length in the frame header>, |
| // } |
| EVENT_TYPE(WEBSOCKET_SENT_FRAME_HEADER) |
| |
| // This event is logged when the browser closes the connection instead of the |
| // server. |
| EVENT_TYPE(WEBSOCKET_CLOSE_TIMEOUT) |
| |
| // This event is logged when the WebSocket frame is wrong or weird and the |
| // browser closes the connection. It contains the following parameters: |
| // { |
| // "code": <WebSocket close code based on |
| // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5>, |
| // "reason":<WebSocket close reason based on |
| // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6>, |
| // "internal_reason": <Detailed reason>, |
| // } |
| EVENT_TYPE(WEBSOCKET_INVALID_FRAME) |
| |
| // This event is logged at TransportSecurityState::ShouldUpgradeToSSL. |
| // The following parameters are attached: |
| // { |
| // "host": <host name> |
| // "get_sts_state_result": <boolean>, |
| // "should_upgrade_to_ssl": <boolean>, |
| // "host_found_in_hsts_bypass_list": <boolean>, |
| // } |
| EVENT_TYPE(TRANSPORT_SECURITY_STATE_SHOULD_UPGRADE_TO_SSL) |
| |
| // ------------------------------------------------------------------------ |
| // Oblivious HTTP |
| // ------------------------------------------------------------------------ |
| |
| // OBLIVIOUS_HTTP_REQUEST measures the time between when Oblivoius HTTP |
| // has begun and when Oblivious HTTP has ended (either success or failure). |
| // The following parameters are attached: |
| // { |
| // "net_error": <The net error code integer, can be a failure or a success>, |
| // "outer_response_error_code": <The HTTP error code of the outer relay HTTP |
| // response, set iff the result fails because the outer HTTP response status |
| // code is not HTTP_OK>, |
| // "inner_response_code": <The HTTP code of the inner gateway HTTP response, |
| // parsed out from the binary HTTP structure> |
| // } |
| EVENT_TYPE(OBLIVIOUS_HTTP_REQUEST) |
| |
| // OBLIVIOUS_HTTP_REQUEST_DATA logs either just the byte count of the request or |
| // the entire request (depending on capture settings), before encryption. |
| EVENT_TYPE(OBLIVIOUS_HTTP_REQUEST_DATA) |
| |
| // OBLIVIOUS_HTTP_RESPONSE_DATA logs either just the byte count of the response |
| // or the entire response (depending on capture settings), after decryption. |
| EVENT_TYPE(OBLIVIOUS_HTTP_RESPONSE_DATA) |
| |
| // OBLIVIOUS_HTTP_RESPONSE_HEADERS logs headers of the response, after |
| // decryption. |
| EVENT_TYPE(OBLIVIOUS_HTTP_RESPONSE_HEADERS) |
| |
| // This event is logged when First-Party Sets metadata is requested/received. |
| // The following parameters are attached to the "end" event: |
| // { |
| // "cache_filter": <string>, |
| // "frame_entry": <string>, |
| // "top_frame_entry": <string>, |
| // } |
| EVENT_TYPE(FIRST_PARTY_SETS_METADATA) |
