From f578a59fe6e0c08ad9cf0339ecbf5f74b1f5f53c Mon Sep 17 00:00:00 2001 From: Andrew Kroh Date: Thu, 22 Aug 2019 15:04:51 -0400 Subject: [PATCH] Update fields.yml for ECS v1.1.0 This updates the fields.ecs.yml file and the vendored Go code to be based on ECS v1.1.0. Relates #13320 --- CHANGELOG.next.asciidoc | 1 + NOTICE.txt | 4 +- auditbeat/docs/fields.asciidoc | 804 +++++++++++++++- auditbeat/include/fields.go | 2 +- .../module/file_integrity/_meta/fields.yml | 4 + auditbeat/module/file_integrity/fields.go | 2 +- filebeat/_meta/fields.common.yml | 31 - filebeat/docs/fields.asciidoc | 859 ++++++++++++++++-- filebeat/include/fields.go | 2 +- filebeat/module/santa/_meta/fields.yml | 5 - filebeat/module/santa/fields.go | 2 +- heartbeat/docs/fields.asciidoc | 814 ++++++++++++++++- heartbeat/include/fields.go | 2 +- journalbeat/docs/fields.asciidoc | 814 ++++++++++++++++- journalbeat/include/fields.go | 2 +- libbeat/_meta/fields.ecs.yml | 560 +++++++++++- metricbeat/docs/fields.asciidoc | 812 ++++++++++++++++- metricbeat/include/fields/fields.go | 2 +- packetbeat/docs/fields.asciidoc | 814 ++++++++++++++++- packetbeat/include/fields.go | 2 +- .../github.com/elastic/ecs/code/go/ecs/as.go | 33 + .../elastic/ecs/code/go/ecs/client.go | 10 + .../elastic/ecs/code/go/ecs/destination.go | 9 + .../github.com/elastic/ecs/code/go/ecs/dns.go | 114 +++ .../elastic/ecs/code/go/ecs/event.go | 31 +- .../elastic/ecs/code/go/ecs/file.go | 27 +- .../elastic/ecs/code/go/ecs/hash.go | 38 + .../elastic/ecs/code/go/ecs/host.go | 3 + .../github.com/elastic/ecs/code/go/ecs/log.go | 4 + .../elastic/ecs/code/go/ecs/process.go | 9 + .../elastic/ecs/code/go/ecs/server.go | 10 + .../elastic/ecs/code/go/ecs/service.go | 12 +- .../elastic/ecs/code/go/ecs/source.go | 10 + .../elastic/ecs/code/go/ecs/tracing.go | 37 + .../elastic/ecs/code/go/ecs/user.go | 4 + .../elastic/ecs/code/go/ecs/version.go | 2 +- vendor/vendor.json | 10 +- winlogbeat/docs/fields.asciidoc | 812 ++++++++++++++++- winlogbeat/include/fields.go | 2 +- x-pack/functionbeat/docs/fields.asciidoc | 814 ++++++++++++++++- x-pack/functionbeat/include/fields.go | 2 +- 41 files changed, 7152 insertions(+), 379 deletions(-) create mode 100644 vendor/github.com/elastic/ecs/code/go/ecs/as.go create mode 100644 vendor/github.com/elastic/ecs/code/go/ecs/dns.go create mode 100644 vendor/github.com/elastic/ecs/code/go/ecs/hash.go create mode 100644 vendor/github.com/elastic/ecs/code/go/ecs/tracing.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index b0753dd9bafa..d5258b37a985 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -224,6 +224,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add a check so alias creation explicitely fails if there is an index with the same name. {pull}13070[13070] - Update kubernetes watcher to use official client-go libraries. {pull}13051[13051] - add_host_metadata is no GA. {pull}13148[13148] +- Update ECS version to v1.1.0. {issue}13320[13320] {pull}13321[13321] *Auditbeat* diff --git a/NOTICE.txt b/NOTICE.txt index 655d57a8cc1e..f88fc2e0ce11 100644 --- a/NOTICE.txt +++ b/NOTICE.txt @@ -700,8 +700,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------- Dependency: github.com/elastic/ecs -Version: v1.0.1 -Revision: ab5e966864a6e2d4bc9fd6e2343e8d7f05f648fb +Version: v1.1.0 +Revision: cc1d96bf3f70a8e6af1e436a0283ef22b6af3dd2 License type (autodetected): Apache-2.0 ./vendor/github.com/elastic/ecs/LICENSE.txt: -------------------------------------------------------------------- diff --git a/auditbeat/docs/fields.asciidoc b/auditbeat/docs/fields.asciidoc index 24db8875c9c7..b9ab11fbf6d5 100644 --- a/auditbeat/docs/fields.asciidoc +++ b/auditbeat/docs/fields.asciidoc @@ -3061,6 +3061,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -3079,6 +3107,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -3210,6 +3260,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -3232,6 +3304,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -3462,6 +3544,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -3593,6 +3697,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -3615,6 +3741,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -3683,6 +3819,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -3768,6 +4096,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -3784,11 +4124,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -3851,11 +4192,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -3883,6 +4224,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -3902,6 +4255,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -3951,49 +4316,122 @@ A file is defined as a set of information that has been created on, or has exist File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. -*`file.ctime`*:: +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- + +*`file.gid`*:: ++ +-- +Primary group ID (GID) of the file. + +type: keyword + +example: 1001 + +-- + +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -4006,6 +4444,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -4015,19 +4455,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -4035,24 +4486,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -4071,6 +4529,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -4080,6 +4540,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -4203,6 +4665,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -4436,6 +4941,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -4649,6 +5175,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -5164,6 +5701,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -5176,6 +5749,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -5226,6 +5810,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -5236,6 +5831,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -5282,6 +5888,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -5413,6 +6041,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -5435,6 +6085,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -5525,9 +6185,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -5600,6 +6260,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -5731,6 +6413,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -5753,6 +6457,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -5821,6 +6535,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -5942,6 +6686,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/auditbeat/include/fields.go b/auditbeat/include/fields.go index 191badf19ded..c9a6b845a6b8 100644 --- a/auditbeat/include/fields.go +++ b/auditbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/auditbeat/module/file_integrity/_meta/fields.yml b/auditbeat/module/file_integrity/_meta/fields.yml index d1eb262b1f99..c34aaaf1d43f 100644 --- a/auditbeat/module/file_integrity/_meta/fields.yml +++ b/auditbeat/module/file_integrity/_meta/fields.yml @@ -22,10 +22,12 @@ description: BLAKE2b-512 hash of the file. - name: md5 + overwrite: true type: keyword description: MD5 hash of the file. - name: sha1 + overwrite: true type: keyword description: SHA1 hash of the file. @@ -34,6 +36,7 @@ description: SHA224 hash of the file. - name: sha256 + overwrite: true type: keyword description: SHA256 hash of the file. @@ -58,6 +61,7 @@ description: SHA3_512 hash of the file. - name: sha512 + overwrite: true type: keyword description: SHA512 hash of the file. diff --git a/auditbeat/module/file_integrity/fields.go b/auditbeat/module/file_integrity/fields.go index 25e04e2d53a4..84341850eb5a 100644 --- a/auditbeat/module/file_integrity/fields.go +++ b/auditbeat/module/file_integrity/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFileIntegrity returns asset data. // This is the base64 encoded gzipped contents of module/file_integrity. func AssetFileIntegrity() string { - return "eJyUkkFvozAUhO/8ivkDyQonoIjDSqy2FVXbU3rIDZn4BVsxEGGnDf++wqJNIkXCPvI0fJ438xY40pDhoDSVqrVU98oOEWCV1ZThWWnCy81ckNn36mRV12b4kGQIvCdYSTgo0sKgppZ6bkmgGqb5LRtNJ86alhGmH7IIWKDlDWWQ3MgIAOxwogx1351P7vvu2b9uBBTcSDLoDr/PLEdL40bGueK67nplZePwBrwVTvrJ9ZmcZCKNQ0kXULvvBAkIVZOxk24ZOdXV7dVvpfmRWFWyJP0hOeNHGr66XkyzO/P/3vLXJ1YtWJK6de/sRw/pq806lL7arH3pScxC6UnM5uiNSHyp7/+TOZqRPPbFbYs89uAx5h3qtsgZm81zZPqfwcicvwAjeUD52yL36H1klmHbO70fNygBp/fiBqZQ+uYQcPyO63H5RvIwqjczsLUkZn/8enPsoOYce767y0Wm3pZ3u/SR2e8AAAD//7nP8bw=" + return "eJykk81u6jAQhfd5inkBuIohEcriSqnaKlXbFV2wQw4eYgsnRrYD5O2ruCk/ElJsusxo8p3jmTMT2GGXwVZIXIvGYqWF7SIAK6zEDF6FRHi7qjM0Gy32Vqgmgy+OBoFqBMsRtgIlM1Bhg5paZFB2Q/2aDbVircRpBMMPWQQwgYbWmAGnhkcAALbbYwaVVu3efd/I/nclgIIajgbU9iwz7S31LzLOFZWV0sLy2uEN0Ia51gOVLbqWgdQXOZ4Am41iyICJCo0d+qaR67q4vfgtJd0hKdckSX9JzvgOu6PSbKjdmH/6yN9fSDkhSeqee2M/ukufLeah9Nli7ktPYhJKT2IyRq9ZMhDUAfVRC4sZWN2ir9bnczKmYTiN/yayLPLYQ4UQ7wUsi5yQ0dn3zHNkHvfukSHDaUB8lkXukZyeuQ6biev34/qf0g/XbwYhR+S4vnMIOB/H9bgdw+mF+ng6vJUCd5nE5J/fNh07aJ+OPb7R04mn3pZXq/Se2e8AAAD//yR/DPc=" } diff --git a/filebeat/_meta/fields.common.yml b/filebeat/_meta/fields.common.yml index da88144ca30d..744fa3b94753 100644 --- a/filebeat/_meta/fields.common.yml +++ b/filebeat/_meta/fields.common.yml @@ -35,12 +35,6 @@ The input type from which the event was generated. This field is set to the value specified for the `type` option in the input section of the Filebeat config file. - - name: event.sequence - type: long - required: false - description: > - The sequence number of this event. - - name: syslog.facility type: long required: false @@ -111,11 +105,6 @@ docker.attrs contains labels and environment variables written by docker's JSON File logging driver. These fields are only available when they are configured in the logging driver options. - - name: event.code - type: keyword - description: > - The code for the log message. - - name: icmp.code type: keyword description: > @@ -131,26 +120,6 @@ description: > IGMP type. - - name: source.as.number - type: long - description: > - Autonomous system number. - - - name: destination.as.number - type: long - description: > - Autonomous system number. - - - name: source.as.organization.name - type: keyword - description: > - Name of organization associated with the autonomous system. - - - name: destination.as.organization.name - type: keyword - description: > - Name of organization associated with the autonomous system. - - name: kafka type: group fields: diff --git a/filebeat/docs/fields.asciidoc b/filebeat/docs/fields.asciidoc index 98f2e45a0d4c..2740d86e0e90 100644 --- a/filebeat/docs/fields.asciidoc +++ b/filebeat/docs/fields.asciidoc @@ -1899,6 +1899,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -1917,6 +1945,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -2048,6 +2098,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -2070,6 +2142,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -2300,6 +2382,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -2431,6 +2535,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -2453,6 +2579,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -2521,6 +2657,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -2606,6 +2934,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -2622,11 +2962,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -2689,11 +3030,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -2721,6 +3062,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -2740,6 +3093,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -2789,10 +3154,31 @@ A file is defined as a set of information that has been created on, or has exist File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + *`file.ctime`*:: + -- -Last time file metadata changed. +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. type: date @@ -2805,13 +3191,25 @@ Device that is the source of the file. type: keyword +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + -- *`file.extension`*:: + -- File extension. -This should allow easy filtering by file extensions. type: keyword @@ -2826,6 +3224,8 @@ Primary group ID (GID) of the file. type: keyword +example: 1001 + -- *`file.group`*:: @@ -2835,6 +3235,44 @@ Primary group name of the file. type: keyword +example: alice + +-- + +*`file.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`file.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`file.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`file.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + -- *`file.inode`*:: @@ -2844,6 +3282,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -2853,19 +3293,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -2873,24 +3324,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -2909,6 +3367,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -2918,6 +3378,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -3023,19 +3485,62 @@ example: Quebec The group fields are meant to represent groups that are relevant to the event. -*`group.id`*:: +*`group.id`*:: ++ +-- +Unique identifier for the group on the system/platform. + +type: keyword + +-- + +*`group.name`*:: ++ +-- +Name of the group. + +type: keyword + +-- + +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: + -- -Unique identifier for the group on the system/platform. +SHA256 hash. type: keyword -- -*`group.name`*:: +*`hash.sha512`*:: + -- -Name of the group. +SHA512 hash. type: keyword @@ -3274,6 +3779,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -3487,6 +4013,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -4002,6 +4539,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -4014,6 +4587,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -4064,6 +4648,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -4074,6 +4669,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -4120,6 +4726,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -4251,6 +4879,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -4273,6 +4923,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -4363,9 +5023,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -4438,6 +5098,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -4569,6 +5251,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -4591,6 +5295,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -4659,6 +5373,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -4780,6 +5524,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- @@ -7864,18 +8618,6 @@ required: True -- -*`event.sequence`*:: -+ --- -The sequence number of this event. - - -type: long - -required: False - --- - *`syslog.facility`*:: + -- @@ -8000,16 +8742,6 @@ type: object -- -*`event.code`*:: -+ --- -The code for the log message. - - -type: keyword - --- - *`icmp.code`*:: + -- @@ -8036,46 +8768,6 @@ type: keyword IGMP type. -type: keyword - --- - -*`source.as.number`*:: -+ --- -Autonomous system number. - - -type: long - --- - -*`destination.as.number`*:: -+ --- -Autonomous system number. - - -type: long - --- - -*`source.as.organization.name`*:: -+ --- -Name of organization associated with the autonomous system. - - -type: keyword - --- - -*`destination.as.organization.name`*:: -+ --- -Name of organization associated with the autonomous system. - - type: keyword -- @@ -13328,15 +14020,6 @@ type: keyword -- -*`hash.sha256`*:: -+ --- -Hash of process executable. - -type: keyword - --- - [[exported-fields-suricata]] == Suricata fields diff --git a/filebeat/include/fields.go b/filebeat/include/fields.go index 2804cc99ba6b..516f2eda67bd 100644 --- a/filebeat/include/fields.go +++ b/filebeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/filebeat/module/santa/_meta/fields.yml b/filebeat/module/santa/_meta/fields.yml index 60ae1de7a650..fea0b03a78ce 100644 --- a/filebeat/module/santa/_meta/fields.yml +++ b/filebeat/module/santa/_meta/fields.yml @@ -63,8 +63,3 @@ - name: certificate.sha256 type: keyword description: SHA256 hash of code signing certificate. - - # Auditbeat FIM is using this field for the same purpose. - - name: hash.sha256 - type: keyword - description: Hash of process executable. diff --git a/filebeat/module/santa/fields.go b/filebeat/module/santa/fields.go index d13c1c57a8fe..cc67c59b2b22 100644 --- a/filebeat/module/santa/fields.go +++ b/filebeat/module/santa/fields.go @@ -32,5 +32,5 @@ func init() { // AssetSanta returns asset data. // This is the base64 encoded gzipped contents of module/santa. func AssetSanta() string { - return "eJyUlF9v2jAQwN/5FKfuZXsoWpnoAw+TMqBrNVARqbS9TSa+EIskZ/kuW/n2k50Uwp+swBPY59/vzr7jFja4HQGrUlQPQIzkOIKb70TrHCH2yzc9AI2cOGPFUDmCrz0AqPdgTrrKsQeQGsw1j8LWLZSqwD3Vf2RrcQRrR5VtVs4w95jm556lEh+4W34DbnD7l5xureOrKqwvYvprOm6tH+iimnZi0ZgYvtITzWbPP7tEkwYIkimpL0SDEG36p3KHiq9Tj6fLly7zMtAgJQeSoa+MQyZnxAVpvEY773I+W3RKTLkOSKC07pIzSm14c6Jsd8cJ+yF0Rqhn8hT/iBaLabRs2oL7rVPtTjzW/qG8KvBg60jzkmETFY60Um9zVhW/B/EV+jiwjoQSyjtQjM6o/CJaHQplVazQdWXG2n854u2eznPu+MtFum/x5H934J/4OO/9UCwWsynE8QTi+efh3WB2kTEgO3Tp8Y3vXMqe7J3HN++6MaWGj6nJkbcsWITu+9RZZVXKNXSrJGtYb4wEnZjUJEqwn1BRUPm79Ubnxu3AMA5HAgtSRwUkfrjYrEs/aW14t5YzNRjeX2qMH6PB8B4yxZkf4nd8HyCqtJEVKoGHpzkYhop9qGSG63Hc/Q2xL8JWzhJj/yBbL7syzccmP+soQWbAV0wqUasc+71/AQAA//8U7uy0" + return "eJyUk82O2jAQgO88xWhP7WFRl4o95FAphfRHBS0iK7W3yhtPiJXEE9lOW96+spMFk8QtcCJj+/s8npl7KPEYgWbSsBmAEabCCO4+Ex0qhNSG72YAHHWmRGMEyQg+zACgW4Mt8bbCGUAusOI6ckv3IFmNZ6r9mWODERwUtU0fmWCeMf3nmcUyu/EUfgWWePxNintx/MPqxiaR/EhWXvxCF3e0kYVjJvSNnnizefoeEq17IJiCme5BOBiicj6WK2T6NvUq2T+HzHtHg5wUmAJtZtrdZEJcE8dbtNuQ86lBxYyQB4cEyrsumVByocuR0u+OEfuT6wyXz/pr+i3e7ZJ437eFnnun/E4can9R1dZ4sTTQPBfY73JHvKv7nJdW/w9iM7T7oFFkKKMqgNKoBKuuonVbQbb1C6rQzTS3fwa8U+ks50G/v0r3MV3/6w1siYf3Pg/FbrdJIE3XkG7fLR8Wm6uMDhnQ5cMXP7lYM1qbxvd1LYXk8CYXFeqjNli77nsbzLKV5hZ6w0zRs14ZGSojcpExg/OM6prkT69GU+N2YVi5I44FuaIaMjtcWhyknTQfHtbqgi2Wj9ca0y/xYvkIBdOFHeKw728AAAD//5mnu+4=" } diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index c99fc1e37331..891a80fb9445 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -484,6 +484,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -502,6 +530,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -633,6 +683,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -655,6 +727,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -885,6 +967,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -1016,6 +1120,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -1038,6 +1164,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -1106,6 +1242,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -1191,6 +1519,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -1207,11 +1547,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -1274,11 +1615,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -1306,6 +1647,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -1325,6 +1678,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -1363,60 +1728,133 @@ type: keyword Reserved for future usage. Please avoid using this field for user data. -type: keyword +type: keyword + +-- + +[float] +=== file + +A file is defined as a set of information that has been created on, or has existed on a filesystem. +File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. + + +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- +*`file.gid`*:: ++ -- +Primary group ID (GID) of the file. -[float] -=== file +type: keyword -A file is defined as a set of information that has been created on, or has existed on a filesystem. -File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +example: 1001 +-- -*`file.ctime`*:: +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -1429,6 +1867,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -1438,19 +1878,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -1458,24 +1909,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -1494,6 +1952,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -1503,6 +1963,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -1626,6 +2088,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -1859,6 +2364,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -2072,6 +2598,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -2587,6 +3124,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -2599,6 +3172,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -2649,6 +3233,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -2659,6 +3254,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -2705,6 +3311,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -2836,6 +3464,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -2858,6 +3508,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -2948,9 +3608,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -3023,6 +3683,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -3154,6 +3836,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -3176,6 +3880,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -3244,6 +3958,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -3365,6 +4109,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 64eaedfe3478..0d6f44cb2b0b 100644 --- a/heartbeat/include/fields.go +++ b/heartbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/journalbeat/docs/fields.asciidoc b/journalbeat/docs/fields.asciidoc index 238b8307dd54..47bef69ce212 100644 --- a/journalbeat/docs/fields.asciidoc +++ b/journalbeat/docs/fields.asciidoc @@ -1061,6 +1061,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -1079,6 +1107,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -1210,6 +1260,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -1232,6 +1304,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -1462,6 +1544,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -1593,6 +1697,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -1615,6 +1741,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -1683,6 +1819,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -1768,6 +2096,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -1784,11 +2124,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -1851,11 +2192,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -1883,6 +2224,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -1902,6 +2255,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -1940,60 +2305,133 @@ type: keyword Reserved for future usage. Please avoid using this field for user data. -type: keyword +type: keyword + +-- + +[float] +=== file + +A file is defined as a set of information that has been created on, or has existed on a filesystem. +File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. + + +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- +*`file.gid`*:: ++ -- +Primary group ID (GID) of the file. -[float] -=== file +type: keyword -A file is defined as a set of information that has been created on, or has existed on a filesystem. -File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +example: 1001 +-- -*`file.ctime`*:: +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -2006,6 +2444,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -2015,19 +2455,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -2035,24 +2486,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -2071,6 +2529,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -2080,6 +2540,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -2203,6 +2665,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -2436,6 +2941,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -2649,6 +3175,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -3164,6 +3701,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -3176,6 +3749,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -3226,6 +3810,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -3236,6 +3831,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -3282,6 +3888,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -3413,6 +4041,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -3435,6 +4085,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -3525,9 +4185,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -3600,6 +4260,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -3731,6 +4413,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -3753,6 +4457,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -3821,6 +4535,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -3942,6 +4686,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/journalbeat/include/fields.go b/journalbeat/include/fields.go index 9620d7b679b8..b0fe0018d7d7 100644 --- a/journalbeat/include/fields.go +++ b/journalbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/libbeat/_meta/fields.ecs.yml b/libbeat/_meta/fields.ecs.yml index 206ed71cb0d3..37a5f7a0512e 100644 --- a/libbeat/_meta/fields.ecs.yml +++ b/libbeat/_meta/fields.ecs.yml @@ -1,5 +1,5 @@ # WARNING! Do not edit this file directly, it was generated by the ECS project, -# based on ECS version 1.0.1. +# based on ECS version 1.1.0. # Please visit https://github.com/elastic/ecs to suggest changes to ECS fields. - key: ecs @@ -110,6 +110,27 @@ ignore_above: 1024 description: Version of the agent. example: 6.0.0-rc2 + - name: as + title: Autonomous System + group: 2 + description: An autonomous system (AS) is a collection of connected Internet Protocol + (IP) routing prefixes under the control of one or more network operators on + behalf of a single administrative entity or domain that presents a common, clearly + defined routing policy to the internet. + type: group + fields: + - name: number + level: extended + type: long + description: Unique number allocated to the autonomous system. The autonomous + system number (ASN) uniquely identifies each network on the Internet. + example: 15169 + - name: organization.name + level: extended + type: keyword + ignore_above: 1024 + description: Organization name. + example: Google LLC - name: client title: Client group: 2 @@ -140,6 +161,18 @@ Then it should be duplicated to `.ip` or `.domain`, depending on which one it is.' + - name: as.number + level: extended + type: long + description: Unique number allocated to the autonomous system. The autonomous + system number (ASN) uniquely identifies each network on the Internet. + example: 15169 + - name: as.organization.name + level: extended + type: keyword + ignore_above: 1024 + description: Organization name. + example: Google LLC - name: bytes level: core type: long @@ -215,6 +248,21 @@ type: keyword ignore_above: 1024 description: MAC address of the client. + - name: nat.ip + level: extended + type: ip + description: 'Translated IP of source based NAT sessions (e.g. internal client + to internet). + + Typically connections traversing load balancers, firewalls, or routers.' + - name: nat.port + level: extended + type: long + format: string + description: 'Translated port of source based NAT sessions (e.g. internal client + to internet). + + Typically connections traversing load balancers, firewalls, or routers.' - name: packets level: core type: long @@ -225,6 +273,13 @@ type: long format: string description: Port of the client. + - name: user.domain + level: extended + type: keyword + ignore_above: 1024 + description: 'Name of the directory the user is a member of. + + For example, an LDAP or Active Directory domain name.' - name: user.email level: extended type: keyword @@ -381,6 +436,18 @@ Then it should be duplicated to `.ip` or `.domain`, depending on which one it is.' + - name: as.number + level: extended + type: long + description: Unique number allocated to the autonomous system. The autonomous + system number (ASN) uniquely identifies each network on the Internet. + example: 15169 + - name: as.organization.name + level: extended + type: keyword + ignore_above: 1024 + description: Organization name. + example: Google LLC - name: bytes level: core type: long @@ -456,6 +523,20 @@ type: keyword ignore_above: 1024 description: MAC address of the destination. + - name: nat.ip + level: extended + type: ip + description: 'Translated ip of destination based NAT sessions (e.g. internet + to private DMZ) + + Typically used with load balancers, firewalls, or routers.' + - name: nat.port + level: extended + type: long + format: string + description: 'Port the source session is translated to by NAT Device. + + Typically used with load balancers, firewalls, or routers.' - name: packets level: core type: long @@ -466,6 +547,13 @@ type: long format: string description: Port of the destination. + - name: user.domain + level: extended + type: keyword + ignore_above: 1024 + description: 'Name of the directory the user is a member of. + + For example, an LDAP or Active Directory domain name.' - name: user.email level: extended type: keyword @@ -507,6 +595,159 @@ ignore_above: 1024 description: Short name or login of the user. example: albert + - name: dns + title: DNS + group: 2 + description: 'Fields describing DNS queries and answers. + + DNS events should either represent a single DNS query prior to getting answers + (`dns.type:query`) or they should represent a full exchange and contain the + query details as well as all of the answers that were provided for this query + (`dns.type:answer`).' + type: group + fields: + - name: answers + level: extended + type: object + object_type: keyword + description: 'An array containing an object for each answer section returned + by the server. + + The main keys that should be present in these objects are defined by ECS. + Records that have more information may contain more keys than what ECS defines. + + Not all DNS data sources give all details about DNS answers. At minimum, answer + objects must contain the `data` key. If more information is available, map + as much of it to ECS as possible, and add any additional fields to the answer + objects as custom fields.' + - name: answers.class + level: extended + type: keyword + ignore_above: 1024 + description: The class of DNS data contained in this resource record. + example: IN + - name: answers.data + level: extended + type: keyword + ignore_above: 1024 + description: 'The data describing the resource. + + The meaning of this data depends on the type and class of the resource record.' + example: 10.10.10.10 + - name: answers.name + level: extended + type: keyword + ignore_above: 1024 + description: 'The domain name to which this resource record pertains. + + If a chain of CNAME is being resolved, each answer''s `name` should be the + one that corresponds with the answer''s `data`. It should not simply be the + original `question.name` repeated.' + example: www.google.com + - name: answers.ttl + level: extended + type: long + description: The time interval in seconds that this resource record may be cached + before it should be discarded. Zero values mean that the data should not be + cached. + example: 180 + - name: answers.type + level: extended + type: keyword + ignore_above: 1024 + description: The type of data contained in this resource record. + example: CNAME + - name: header_flags + level: extended + type: keyword + ignore_above: 1024 + description: 'Array of 2 letter DNS header flags. + + Expected values are: AA, TC, RD, RA, AD, CD, DO.' + example: + - RD + - RA + - name: id + level: extended + type: keyword + ignore_above: 1024 + description: The DNS packet identifier assigned by the program that generated + the query. The identifier is copied to the response. + example: 62111 + - name: op_code + level: extended + type: keyword + ignore_above: 1024 + description: The DNS operation code that specifies the kind of query in the + message. This value is set by the originator of a query and copied into the + response. + example: QUERY + - name: question.class + level: extended + type: keyword + ignore_above: 1024 + description: The class of of records being queried. + example: IN + - name: question.name + level: extended + type: keyword + ignore_above: 1024 + description: 'The name being queried. + + If the name field contains non-printable characters (below 32 or above 126), + those characters should be represented as escaped base 10 integers (\DDD). + Back slashes and quotes should be escaped. Tabs, carriage returns, and line + feeds should be converted to \t, \r, and \n respectively.' + example: www.google.com + - name: question.registered_domain + level: extended + type: keyword + ignore_above: 1024 + description: 'The highest registered domain, stripped of the subdomain. + + For example, the registered domain for "foo.google.com" is "google.com". + + This value can be determined precisely with a list like the public suffix + list (http://publicsuffix.org). Trying to approximate this by simply taking + the last two labels will not work well for TLDs such as "co.uk".' + example: google.com + - name: question.type + level: extended + type: keyword + ignore_above: 1024 + description: The type of record being queried. + example: AAAA + - name: resolved_ip + level: extended + type: ip + description: 'Array containing all IPs seen in `answers.data`. + + The `answers` array can be difficult to use, because of the variety of data + formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` + makes it possible to index them as IP addresses, and makes them easier to + visualize and query for.' + example: + - 10.10.10.10 + - 10.10.10.11 + - name: response_code + level: extended + type: keyword + ignore_above: 1024 + description: The DNS response code. + example: NOERROR + - name: type + level: extended + type: keyword + ignore_above: 1024 + description: 'The type of DNS event captured, query or answer. + + If your source of DNS events only gives you DNS queries, you should only create + dns events of type `dns.type:query`. + + If your source of DNS events gives you answers as well, you should create + one event per query (optionally as soon as the query is seen). And a second + event containing all query details as well as an array of answers.' + example: answer - name: ecs title: ECS group: 2 @@ -585,6 +826,16 @@ multiple actions. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.' example: user-management + - name: code + level: extended + type: keyword + ignore_above: 1024 + description: 'Identification code for this event, if one exists. + + Some event sources use event codes to identify messages unambiguously, regardless + of message language or wording adjustments over time. An example of this is + the Windows Event ID.' + example: 4648 - name: created level: core type: date @@ -606,10 +857,13 @@ ignore_above: 1024 description: 'Name of the dataset. - The concept of a `dataset` (fileset / metricset) is used in Beats as a subset - of modules. It contains the information which is currently stored in metricset.name - and metricset.module or fileset.name.' - example: stats + If an event source publishes more than one type of log or events (e.g. access + log, error log), the dataset is used to specify which one the event comes + from. + + It''s recommended but not required to start the dataset name with the module + name, followed by a dot, then the dataset name.' + example: apache.access - name: duration level: core type: long @@ -656,8 +910,10 @@ ignore_above: 1024 description: 'Name of the module this data is coming from. - This information is coming from the modules used in Beats or Logstash.' - example: mysql + If your monitoring agent supports the concept of modules or plugins to process + events of a given source (e.g. Apache logs), `event.module` should contain + the name of this module.' + example: apache - name: original level: core type: keyword @@ -679,6 +935,17 @@ versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.' example: success + - name: provider + level: extended + type: keyword + ignore_above: 1024 + description: 'Source of the event. + + Event transports such as Syslog or the Windows Event Log typically mention + the source of an event. It can be the name of the software that generated + the event (e.g. Sysmon, httpd), or of a subsystem of the operating system + (kernel, Microsoft-Windows-Security-Auditing).' + example: kernel - name: risk_score level: core type: float @@ -692,6 +959,14 @@ This is mainly useful if you use more than one system that assigns risk scores, and you want to see a normalized value across all systems.' + - name: sequence + level: extended + type: long + format: string + description: 'Sequence number of the event. + + The sequence number is a value published by some event sources, to make the + exact ordering of events unambiguous, regarless of the timestamp precision.' - name: severity level: core type: long @@ -734,62 +1009,116 @@ the event or metric.' type: group fields: + - name: accessed + level: extended + type: date + description: 'Last time the file was accessed. + + Note that not all filesystems keep track of access time.' + - name: created + level: extended + type: date + description: 'File creation time. + + Note that not all filesystems store the creation time.' - name: ctime level: extended type: date - description: Last time file metadata changed. + description: 'Last time the file attributes or metadata changed. + + Note that changes to the file content will update `mtime`. This implies `ctime` + will be adjusted at the same time, since `mtime` is an attribute of the file.' - name: device level: extended type: keyword ignore_above: 1024 description: Device that is the source of the file. + example: sda + - name: directory + level: extended + type: keyword + ignore_above: 1024 + description: Directory where the file is located. + example: /home/alice - name: extension level: extended type: keyword ignore_above: 1024 - description: 'File extension. - - This should allow easy filtering by file extensions.' + description: File extension. example: png - name: gid level: extended type: keyword ignore_above: 1024 description: Primary group ID (GID) of the file. + example: '1001' - name: group level: extended type: keyword ignore_above: 1024 description: Primary group name of the file. + example: alice + - name: hash.md5 + level: extended + type: keyword + ignore_above: 1024 + description: MD5 hash. + - name: hash.sha1 + level: extended + type: keyword + ignore_above: 1024 + description: SHA1 hash. + - name: hash.sha256 + level: extended + type: keyword + ignore_above: 1024 + description: SHA256 hash. + - name: hash.sha512 + level: extended + type: keyword + ignore_above: 1024 + description: SHA512 hash. - name: inode level: extended type: keyword ignore_above: 1024 description: Inode representing the file in the filesystem. + example: '256383' - name: mode level: extended type: keyword ignore_above: 1024 description: Mode of the file in octal representation. - example: 416 + example: '0640' - name: mtime level: extended type: date - description: Last time file content was modified. + description: Last time the file content was modified. + - name: name + level: extended + type: keyword + ignore_above: 1024 + description: Name of the file including the extension, without the directory. + example: example.png - name: owner level: extended type: keyword ignore_above: 1024 description: File owner's username. + example: alice - name: path level: extended type: keyword ignore_above: 1024 - description: Path to the file. + description: Full path to the file. + example: /home/alice/example.png - name: size level: extended type: long - description: File size in bytes (field is only added when `type` is `file`). + description: 'File size in bytes. + + Only relevant when `file.type` is "file".' + example: 16384 - name: target_path level: extended type: keyword @@ -800,11 +1129,13 @@ type: keyword ignore_above: 1024 description: File type (file, dir, or symlink). + example: file - name: uid level: extended type: keyword ignore_above: 1024 description: The user ID (UID) or security identifier (SID) of the file owner. + example: '1001' - name: geo title: Geo group: 2 @@ -885,6 +1216,36 @@ type: keyword ignore_above: 1024 description: Name of the group. + - name: hash + title: Hash + group: 2 + description: 'The hash fields represent different hash algorithms and their values. + + Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for + other hashes by lowercasing the hash algorithm name and using underscore separators + as appropriate (snake case, e.g. sha3_512).' + type: group + fields: + - name: md5 + level: extended + type: keyword + ignore_above: 1024 + description: MD5 hash. + - name: sha1 + level: extended + type: keyword + ignore_above: 1024 + description: SHA1 hash. + - name: sha256 + level: extended + type: keyword + ignore_above: 1024 + description: SHA256 hash. + - name: sha512 + level: extended + type: keyword + ignore_above: 1024 + description: SHA512 hash. - name: host title: Host group: 2 @@ -1033,6 +1394,18 @@ For Cloud providers this can be the machine type like `t2.medium`. If vm, this could be the container, for example, or other information meaningful in your environment.' + - name: uptime + level: extended + type: long + description: Seconds the host has been up. + example: 1325 + - name: user.domain + level: extended + type: keyword + ignore_above: 1024 + description: 'Name of the directory the user is a member of. + + For example, an LDAP or Active Directory domain name.' - name: user.email level: extended type: keyword @@ -1158,6 +1531,13 @@ Some examples are `warn`, `error`, `i`.' example: err + - name: logger + level: core + type: keyword + ignore_above: 1024 + description: The name of the logger inside an application. This is usually the + name of the class which initialized the logger, or can be a custom name. + example: org.elasticsearch.bootstrap.Bootstrap - name: original level: core type: keyword @@ -1516,6 +1896,26 @@ ignore_above: 1024 description: Absolute path to the process executable. example: /usr/bin/ssh + - name: hash.md5 + level: extended + type: keyword + ignore_above: 1024 + description: MD5 hash. + - name: hash.sha1 + level: extended + type: keyword + ignore_above: 1024 + description: SHA1 hash. + - name: hash.sha256 + level: extended + type: keyword + ignore_above: 1024 + description: SHA256 hash. + - name: hash.sha512 + level: extended + type: keyword + ignore_above: 1024 + description: SHA512 hash. - name: name level: extended type: keyword @@ -1524,6 +1924,11 @@ Sometimes called program name or similar.' example: ssh + - name: pgid + level: extended + type: long + format: string + description: Identifier of the group of processes the process belongs to. - name: pid level: core type: long @@ -1547,6 +1952,12 @@ format: string description: Thread ID. example: 4242 + - name: thread.name + level: extended + type: keyword + ignore_above: 1024 + description: Thread name. + example: thread-0 - name: title level: extended type: keyword @@ -1555,6 +1966,11 @@ The proctitle, some times the same as process name. Can also be different: for example a browser setting its title to the web page currently opened.' + - name: uptime + level: extended + type: long + description: Seconds the process has been up. + example: 1325 - name: working_directory level: extended type: keyword @@ -1611,6 +2027,18 @@ Then it should be duplicated to `.ip` or `.domain`, depending on which one it is.' + - name: as.number + level: extended + type: long + description: Unique number allocated to the autonomous system. The autonomous + system number (ASN) uniquely identifies each network on the Internet. + example: 15169 + - name: as.organization.name + level: extended + type: keyword + ignore_above: 1024 + description: Organization name. + example: Google LLC - name: bytes level: core type: long @@ -1686,6 +2114,21 @@ type: keyword ignore_above: 1024 description: MAC address of the server. + - name: nat.ip + level: extended + type: ip + description: 'Translated ip of destination based NAT sessions (e.g. internet + to private DMZ) + + Typically used with load balancers, firewalls, or routers.' + - name: nat.port + level: extended + type: long + format: string + description: 'Translated port of destination based NAT sessions (e.g. internet + to private DMZ) + + Typically used with load balancers, firewalls, or routers.' - name: packets level: core type: long @@ -1696,6 +2139,13 @@ type: long format: string description: Port of the server. + - name: user.domain + level: extended + type: keyword + ignore_above: 1024 + description: 'Name of the directory the user is a member of. + + For example, an LDAP or Active Directory domain name.' - name: user.email level: extended type: keyword @@ -1758,13 +2208,15 @@ level: core type: keyword ignore_above: 1024 - description: 'Unique identifier of the running service. + description: 'Unique identifier of the running service. If the service is comprised + of many nodes, the `service.id` should be the same for all nodes. - This id should uniquely identify this service. This makes it possible to correlate - logs and metrics for one specific service. + This id should uniquely identify the service. This makes it possible to correlate + logs and metrics for one specific service, no matter which particular node + emitted the event. - Example: If you are experiencing issues with one redis instance, you can filter - on that id to see metrics and logs for that single instance.' + Note that if you need to see the events from one specific host of the service, + you should filter on that `host.name` or `host.id` instead.' example: d37e5ebfe0ae6c4972dbe9f0174a1637bb8247f6 - name: name level: core @@ -1826,6 +2278,18 @@ Then it should be duplicated to `.ip` or `.domain`, depending on which one it is.' + - name: as.number + level: extended + type: long + description: Unique number allocated to the autonomous system. The autonomous + system number (ASN) uniquely identifies each network on the Internet. + example: 15169 + - name: as.organization.name + level: extended + type: keyword + ignore_above: 1024 + description: Organization name. + example: Google LLC - name: bytes level: core type: long @@ -1901,6 +2365,21 @@ type: keyword ignore_above: 1024 description: MAC address of the source. + - name: nat.ip + level: extended + type: ip + description: 'Translated ip of source based NAT sessions (e.g. internal client + to internet) + + Typically connections traversing load balancers, firewalls, or routers.' + - name: nat.port + level: extended + type: long + format: string + description: 'Translated port of source based NAT sessions. (e.g. internal client + to internet) + + Typically used with load balancers, firewalls, or routers.' - name: packets level: core type: long @@ -1911,6 +2390,13 @@ type: long format: string description: Port of the source. + - name: user.domain + level: extended + type: keyword + ignore_above: 1024 + description: 'Name of the directory the user is a member of. + + For example, an LDAP or Active Directory domain name.' - name: user.email level: extended type: keyword @@ -1952,6 +2438,33 @@ ignore_above: 1024 description: Short name or login of the user. example: albert + - name: tracing + title: Tracing + group: 2 + description: Distributed tracing makes it possible to analyze performance throughout + a microservice architecture all in one view. This is accomplished by tracing + all of the requests - from the initial web request in the front-end service + - to queries made through multiple back-end services. + type: group + fields: + - name: trace.id + level: extended + type: keyword + ignore_above: 1024 + description: 'Unique identifier of the trace. + + A trace groups multiple events like transactions that belong together. For + example, a user request handled by multiple inter-connected services.' + example: 4bf92f3577b34da6a3ce929d0e0e4736 + - name: transaction.id + level: extended + type: keyword + ignore_above: 1024 + description: 'Unique identifier of the transaction. + + A transaction is the highest level of work measured within a service, such + as a request to a server.' + example: 00f067aa0ba902b7 - name: url title: URL group: 2 @@ -2044,6 +2557,13 @@ provide an array that includes all of them.' type: group fields: + - name: domain + level: extended + type: keyword + ignore_above: 1024 + description: 'Name of the directory the user is a member of. + + For example, an LDAP or Active Directory domain name.' - name: email level: extended type: keyword diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 8ee053fc4a93..1ad166b8a556 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -5975,6 +5975,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -5993,6 +6021,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -6124,6 +6174,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -6146,6 +6218,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -6376,6 +6458,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -6507,6 +6611,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -6529,6 +6655,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -6597,6 +6733,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -6682,6 +7010,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -6698,11 +7038,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -6765,11 +7106,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -6797,6 +7138,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -6816,6 +7169,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -6858,56 +7223,129 @@ type: keyword -- -[float] -=== file +[float] +=== file + +A file is defined as a set of information that has been created on, or has existed on a filesystem. +File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. + + +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- + +*`file.gid`*:: ++ +-- +Primary group ID (GID) of the file. + +type: keyword -A file is defined as a set of information that has been created on, or has existed on a filesystem. -File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +example: 1001 +-- -*`file.ctime`*:: +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -6920,6 +7358,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -6929,19 +7369,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -6949,24 +7400,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -6985,6 +7443,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -6994,6 +7454,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -7117,6 +7579,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -7350,6 +7855,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -7563,6 +8089,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -8078,6 +8615,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -8090,6 +8663,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -8140,6 +8724,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -8150,6 +8745,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -8196,6 +8802,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -8327,6 +8955,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -8349,6 +8999,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -8439,9 +9099,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -8514,6 +9174,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -8645,6 +9327,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -8667,6 +9371,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -8735,6 +9449,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -8856,6 +9600,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/metricbeat/include/fields/fields.go b/metricbeat/include/fields/fields.go index 905e6f8636d4..9324b3bc6202 100644 --- a/metricbeat/include/fields/fields.go +++ b/metricbeat/include/fields/fields.go @@ -32,5 +32,5 @@ func init() { // AssetLibbeatFieldsYml returns asset data. // This is the base64 encoded gzipped contents of ../libbeat/fields.yml. func AssetLibbeatFieldsYml() string { - return "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" + return "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" } diff --git a/packetbeat/docs/fields.asciidoc b/packetbeat/docs/fields.asciidoc index db45b56f65f0..aeb760ad7941 100644 --- a/packetbeat/docs/fields.asciidoc +++ b/packetbeat/docs/fields.asciidoc @@ -2386,6 +2386,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -2404,6 +2432,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -2535,6 +2585,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -2557,6 +2629,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -2787,6 +2869,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -2918,6 +3022,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -2940,6 +3066,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -3008,6 +3144,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -3093,6 +3421,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -3109,11 +3449,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -3176,11 +3517,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -3208,6 +3549,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -3227,6 +3580,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -3265,60 +3630,133 @@ type: keyword Reserved for future usage. Please avoid using this field for user data. -type: keyword +type: keyword + +-- + +[float] +=== file + +A file is defined as a set of information that has been created on, or has existed on a filesystem. +File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. + + +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- +*`file.gid`*:: ++ -- +Primary group ID (GID) of the file. -[float] -=== file +type: keyword -A file is defined as a set of information that has been created on, or has existed on a filesystem. -File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +example: 1001 +-- -*`file.ctime`*:: +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -3331,6 +3769,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -3340,19 +3780,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -3360,24 +3811,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -3396,6 +3854,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -3405,6 +3865,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -3528,6 +3990,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -3761,6 +4266,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -3974,6 +4500,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -4489,6 +5026,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -4501,6 +5074,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -4551,6 +5135,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -4561,6 +5156,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -4607,6 +5213,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -4738,6 +5366,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -4760,6 +5410,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -4850,9 +5510,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -4925,6 +5585,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -5056,6 +5738,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -5078,6 +5782,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -5146,6 +5860,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -5267,6 +6011,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/packetbeat/include/fields.go b/packetbeat/include/fields.go index 8d2edae07a55..eea72ff9ee4f 100644 --- a/packetbeat/include/fields.go +++ b/packetbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "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" + return "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" } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/as.go b/vendor/github.com/elastic/ecs/code/go/ecs/as.go new file mode 100644 index 000000000000..32451693f648 --- /dev/null +++ b/vendor/github.com/elastic/ecs/code/go/ecs/as.go @@ -0,0 +1,33 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Code generated by scripts/gocodegen.go - DO NOT EDIT. + +package ecs + +// An autonomous system (AS) is a collection of connected Internet Protocol +// (IP) routing prefixes under the control of one or more network operators on +// behalf of a single administrative entity or domain that presents a common, +// clearly defined routing policy to the internet. +type AS struct { + // Unique number allocated to the autonomous system. The autonomous system + // number (ASN) uniquely identifies each network on the Internet. + Number int64 `ecs:"number"` + + // Organization name. + OrganizationName string `ecs:"organization.name"` +} diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/client.go b/vendor/github.com/elastic/ecs/code/go/ecs/client.go index 73bead648114..4aea0d36bbd8 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/client.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/client.go @@ -58,4 +58,14 @@ type Client struct { // Packets sent from the client to the server. Packets int64 `ecs:"packets"` + + // Translated IP of source based NAT sessions (e.g. internal client to + // internet). + // Typically connections traversing load balancers, firewalls, or routers. + NatIP string `ecs:"nat.ip"` + + // Translated port of source based NAT sessions (e.g. internal client to + // internet). + // Typically connections traversing load balancers, firewalls, or routers. + NatPort int64 `ecs:"nat.port"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/destination.go b/vendor/github.com/elastic/ecs/code/go/ecs/destination.go index 26a70e9cb7b4..4976afc54ee3 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/destination.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/destination.go @@ -47,4 +47,13 @@ type Destination struct { // Packets sent from the destination to the source. Packets int64 `ecs:"packets"` + + // Translated ip of destination based NAT sessions (e.g. internet to + // private DMZ) + // Typically used with load balancers, firewalls, or routers. + NatIP string `ecs:"nat.ip"` + + // Port the source session is translated to by NAT Device. + // Typically used with load balancers, firewalls, or routers. + NatPort int64 `ecs:"nat.port"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/dns.go b/vendor/github.com/elastic/ecs/code/go/ecs/dns.go new file mode 100644 index 000000000000..17b930f84c85 --- /dev/null +++ b/vendor/github.com/elastic/ecs/code/go/ecs/dns.go @@ -0,0 +1,114 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Code generated by scripts/gocodegen.go - DO NOT EDIT. + +package ecs + +// Fields describing DNS queries and answers. +// DNS events should either represent a single DNS query prior to getting +// answers (`dns.type:query`) or they should represent a full exchange and +// contain the query details as well as all of the answers that were provided +// for this query (`dns.type:answer`). +type Dns struct { + // The type of DNS event captured, query or answer. + // If your source of DNS events only gives you DNS queries, you should only + // create dns events of type `dns.type:query`. + // If your source of DNS events gives you answers as well, you should + // create one event per query (optionally as soon as the query is seen). + // And a second event containing all query details as well as an array of + // answers. + Type string `ecs:"type"` + + // The DNS packet identifier assigned by the program that generated the + // query. The identifier is copied to the response. + ID string `ecs:"id"` + + // The DNS operation code that specifies the kind of query in the message. + // This value is set by the originator of a query and copied into the + // response. + OpCode string `ecs:"op_code"` + + // Array of 2 letter DNS header flags. + // Expected values are: AA, TC, RD, RA, AD, CD, DO. + HeaderFlags string `ecs:"header_flags"` + + // The DNS response code. + ResponseCode string `ecs:"response_code"` + + // The name being queried. + // If the name field contains non-printable characters (below 32 or above + // 126), those characters should be represented as escaped base 10 integers + // (\DDD). Back slashes and quotes should be escaped. Tabs, carriage + // returns, and line feeds should be converted to \t, \r, and \n + // respectively. + QuestionName string `ecs:"question.name"` + + // The type of record being queried. + QuestionType string `ecs:"question.type"` + + // The class of of records being queried. + QuestionClass string `ecs:"question.class"` + + // The highest registered domain, stripped of the subdomain. + // For example, the registered domain for "foo.google.com" is "google.com". + // This value can be determined precisely with a list like the public + // suffix list (http://publicsuffix.org). Trying to approximate this by + // simply taking the last two labels will not work well for TLDs such as + // "co.uk". + QuestionRegisteredDomain string `ecs:"question.registered_domain"` + + // An array containing an object for each answer section returned by the + // server. + // The main keys that should be present in these objects are defined by + // ECS. Records that have more information may contain more keys than what + // ECS defines. + // Not all DNS data sources give all details about DNS answers. At minimum, + // answer objects must contain the `data` key. If more information is + // available, map as much of it to ECS as possible, and add any additional + // fields to the answer objects as custom fields. + Answers map[string]interface{} `ecs:"answers"` + + // The domain name to which this resource record pertains. + // If a chain of CNAME is being resolved, each answer's `name` should be + // the one that corresponds with the answer's `data`. It should not simply + // be the original `question.name` repeated. + AnswersName string `ecs:"answers.name"` + + // The type of data contained in this resource record. + AnswersType string `ecs:"answers.type"` + + // The class of DNS data contained in this resource record. + AnswersClass string `ecs:"answers.class"` + + // The time interval in seconds that this resource record may be cached + // before it should be discarded. Zero values mean that the data should not + // be cached. + AnswersTtl int64 `ecs:"answers.ttl"` + + // The data describing the resource. + // The meaning of this data depends on the type and class of the resource + // record. + AnswersData string `ecs:"answers.data"` + + // Array containing all IPs seen in `answers.data`. + // The `answers` array can be difficult to use, because of the variety of + // data formats it can contain. Extracting all IP addresses seen in there + // to `dns.resolved_ip` makes it possible to index them as IP addresses, + // and makes them easier to visualize and query for. + ResolvedIP string `ecs:"resolved_ip"` +} diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/event.go b/vendor/github.com/elastic/ecs/code/go/ecs/event.go index 56fcebe05615..f43b4f8f0a1f 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/event.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/event.go @@ -37,6 +37,12 @@ type Event struct { // Unique ID to describe the event. ID string `ecs:"id"` + // Identification code for this event, if one exists. + // Some event sources use event codes to identify messages unambiguously, + // regardless of message language or wording adjustments over time. An + // example of this is the Windows Event ID. + Code string `ecs:"code"` + // The kind of the event. // This gives information about what type of information the event // contains, without being specific to the contents of the event. Examples @@ -71,15 +77,26 @@ type Event struct { Type string `ecs:"type"` // Name of the module this data is coming from. - // This information is coming from the modules used in Beats or Logstash. + // If your monitoring agent supports the concept of modules or plugins to + // process events of a given source (e.g. Apache logs), `event.module` + // should contain the name of this module. Module string `ecs:"module"` // Name of the dataset. - // The concept of a `dataset` (fileset / metricset) is used in Beats as a - // subset of modules. It contains the information which is currently stored - // in metricset.name and metricset.module or fileset.name. + // If an event source publishes more than one type of log or events (e.g. + // access log, error log), the dataset is used to specify which one the + // event comes from. + // It's recommended but not required to start the dataset name with the + // module name, followed by a dot, then the dataset name. Dataset string `ecs:"dataset"` + // Source of the event. + // Event transports such as Syslog or the Windows Event Log typically + // mention the source of an event. It can be the name of the software that + // generated the event (e.g. Sysmon, httpd), or of a subsystem of the + // operating system (kernel, Microsoft-Windows-Security-Auditing). + Provider string `ecs:"provider"` + // Severity describes the original severity of the event. What the // different severity values mean can very different between use cases. // It's up to the implementer to make sure severities are consistent across @@ -100,6 +117,12 @@ type Event struct { // difference between the end and start time. Duration time.Duration `ecs:"duration"` + // Sequence number of the event. + // The sequence number is a value published by some event sources, to make + // the exact ordering of events unambiguous, regarless of the timestamp + // precision. + Sequence int64 `ecs:"sequence"` + // This field should be populated when the event's timestamp does not // include timezone information already (e.g. default Syslog timestamps). // It's optional otherwise. diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/file.go b/vendor/github.com/elastic/ecs/code/go/ecs/file.go index 8b3dfc8a58ee..0ea31294e61c 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/file.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/file.go @@ -30,14 +30,19 @@ import ( // services). File fields provide details about the affected file associated // with the event or metric. type File struct { - // Path to the file. + // Name of the file including the extension, without the directory. + Name string `ecs:"name"` + + // Directory where the file is located. + Directory string `ecs:"directory"` + + // Full path to the file. Path string `ecs:"path"` // Target path for symlinks. TargetPath string `ecs:"target_path"` // File extension. - // This should allow easy filtering by file extensions. Extension string `ecs:"extension"` // File type (file, dir, or symlink). @@ -64,12 +69,24 @@ type File struct { // Mode of the file in octal representation. Mode string `ecs:"mode"` - // File size in bytes (field is only added when `type` is `file`). + // File size in bytes. + // Only relevant when `file.type` is "file". Size int64 `ecs:"size"` - // Last time file content was modified. + // Last time the file content was modified. Mtime time.Time `ecs:"mtime"` - // Last time file metadata changed. + // Last time the file attributes or metadata changed. + // Note that changes to the file content will update `mtime`. This implies + // `ctime` will be adjusted at the same time, since `mtime` is an attribute + // of the file. Ctime time.Time `ecs:"ctime"` + + // File creation time. + // Note that not all filesystems store the creation time. + Created time.Time `ecs:"created"` + + // Last time the file was accessed. + // Note that not all filesystems keep track of access time. + Accessed time.Time `ecs:"accessed"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/hash.go b/vendor/github.com/elastic/ecs/code/go/ecs/hash.go new file mode 100644 index 000000000000..070b4256cc0f --- /dev/null +++ b/vendor/github.com/elastic/ecs/code/go/ecs/hash.go @@ -0,0 +1,38 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Code generated by scripts/gocodegen.go - DO NOT EDIT. + +package ecs + +// The hash fields represent different hash algorithms and their values. +// Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields +// for other hashes by lowercasing the hash algorithm name and using underscore +// separators as appropriate (snake case, e.g. sha3_512). +type Hash struct { + // MD5 hash. + Md5 string `ecs:"md5"` + + // SHA1 hash. + Sha1 string `ecs:"sha1"` + + // SHA256 hash. + Sha256 string `ecs:"sha256"` + + // SHA512 hash. + Sha512 string `ecs:"sha512"` +} diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/host.go b/vendor/github.com/elastic/ecs/code/go/ecs/host.go index 6d652bf9e6bc..c002e7dd681b 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/host.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/host.go @@ -53,6 +53,9 @@ type Host struct { // meaningful in your environment. Type string `ecs:"type"` + // Seconds the host has been up. + Uptime int64 `ecs:"uptime"` + // Operating system architecture. Architecture string `ecs:"architecture"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/log.go b/vendor/github.com/elastic/ecs/code/go/ecs/log.go index 11f3ab8febc6..492319a8b86d 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/log.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/log.go @@ -34,4 +34,8 @@ type Log struct { // This field is not indexed and doc_values are disabled so it can't be // queried but the value can be retrieved from `_source`. Original string `ecs:"original"` + + // The name of the logger inside an application. This is usually the name + // of the class which initialized the logger, or can be a custom name. + Logger string `ecs:"logger"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/process.go b/vendor/github.com/elastic/ecs/code/go/ecs/process.go index 96bcabe053e5..7ce0851a3ec8 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/process.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/process.go @@ -38,6 +38,9 @@ type Process struct { // Parent process' pid. PPID int64 `ecs:"ppid"` + // Identifier of the group of processes the process belongs to. + PGID int64 `ecs:"pgid"` + // Array of process arguments. // May be filtered to protect sensitive information. Args []string `ecs:"args"` @@ -54,9 +57,15 @@ type Process struct { // Thread ID. ThreadID int64 `ecs:"thread.id"` + // Thread name. + ThreadName string `ecs:"thread.name"` + // The time the process started. Start time.Time `ecs:"start"` + // Seconds the process has been up. + Uptime int64 `ecs:"uptime"` + // The working directory of the process. WorkingDirectory string `ecs:"working_directory"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/server.go b/vendor/github.com/elastic/ecs/code/go/ecs/server.go index ca81c34ceba6..5b4b25db6a34 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/server.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/server.go @@ -58,4 +58,14 @@ type Server struct { // Packets sent from the server to the client. Packets int64 `ecs:"packets"` + + // Translated ip of destination based NAT sessions (e.g. internet to + // private DMZ) + // Typically used with load balancers, firewalls, or routers. + NatIP string `ecs:"nat.ip"` + + // Translated port of destination based NAT sessions (e.g. internet to + // private DMZ) + // Typically used with load balancers, firewalls, or routers. + NatPort int64 `ecs:"nat.port"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/service.go b/vendor/github.com/elastic/ecs/code/go/ecs/service.go index 2e70e0906e4c..df93fb1df650 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/service.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/service.go @@ -24,11 +24,13 @@ package ecs // These fields help you find and correlate logs for a specific service and // version. type Service struct { - // Unique identifier of the running service. - // This id should uniquely identify this service. This makes it possible to - // correlate logs and metrics for one specific service. - // Example: If you are experiencing issues with one redis instance, you can - // filter on that id to see metrics and logs for that single instance. + // Unique identifier of the running service. If the service is comprised of + // many nodes, the `service.id` should be the same for all nodes. + // This id should uniquely identify the service. This makes it possible to + // correlate logs and metrics for one specific service, no matter which + // particular node emitted the event. + // Note that if you need to see the events from one specific host of the + // service, you should filter on that `host.name` or `host.id` instead. ID string `ecs:"id"` // Name of the service data is collected from. diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/source.go b/vendor/github.com/elastic/ecs/code/go/ecs/source.go index fd3ea5dd8f94..34cbeb819165 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/source.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/source.go @@ -47,4 +47,14 @@ type Source struct { // Packets sent from the source to the destination. Packets int64 `ecs:"packets"` + + // Translated ip of source based NAT sessions (e.g. internal client to + // internet) + // Typically connections traversing load balancers, firewalls, or routers. + NatIP string `ecs:"nat.ip"` + + // Translated port of source based NAT sessions. (e.g. internal client to + // internet) + // Typically used with load balancers, firewalls, or routers. + NatPort int64 `ecs:"nat.port"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/tracing.go b/vendor/github.com/elastic/ecs/code/go/ecs/tracing.go new file mode 100644 index 000000000000..7d5435c44d7d --- /dev/null +++ b/vendor/github.com/elastic/ecs/code/go/ecs/tracing.go @@ -0,0 +1,37 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you under +// the Apache License, Version 2.0 (the "License"); you may +// not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Code generated by scripts/gocodegen.go - DO NOT EDIT. + +package ecs + +// Distributed tracing makes it possible to analyze performance throughout a +// microservice architecture all in one view. This is accomplished by tracing +// all of the requests - from the initial web request in the front-end service +// - to queries made through multiple back-end services. +type Tracing struct { + // Unique identifier of the trace. + // A trace groups multiple events like transactions that belong together. + // For example, a user request handled by multiple inter-connected + // services. + TraceID string `ecs:"trace.id"` + + // Unique identifier of the transaction. + // A transaction is the highest level of work measured within a service, + // such as a request to a server. + TransactionID string `ecs:"transaction.id"` +} diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/user.go b/vendor/github.com/elastic/ecs/code/go/ecs/user.go index 411a07003853..e80effb7710a 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/user.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/user.go @@ -40,4 +40,8 @@ type User struct { // Useful if `user.id` or `user.name` contain confidential information and // cannot be used. Hash string `ecs:"hash"` + + // Name of the directory the user is a member of. + // For example, an LDAP or Active Directory domain name. + Domain string `ecs:"domain"` } diff --git a/vendor/github.com/elastic/ecs/code/go/ecs/version.go b/vendor/github.com/elastic/ecs/code/go/ecs/version.go index c951aae1354a..981ba9c97cbf 100644 --- a/vendor/github.com/elastic/ecs/code/go/ecs/version.go +++ b/vendor/github.com/elastic/ecs/code/go/ecs/version.go @@ -20,4 +20,4 @@ package ecs // Version is the Elastic Common Schema version from which this was generated. -const Version = "1.0.1" +const Version = "1.1.0" diff --git a/vendor/vendor.json b/vendor/vendor.json index aa8b29cf12d8..65290f5ce30e 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -932,12 +932,12 @@ "revisionTime": "2016-08-05T00:47:13Z" }, { - "checksumSHA1": "rXP3Wn/PiAk8DQLcy9Bjz7wT7Po=", + "checksumSHA1": "iFJq2WHNE7dIM4+7yOflAahyk0Q=", "path": "github.com/elastic/ecs/code/go/ecs", - "revision": "ab5e966864a6e2d4bc9fd6e2343e8d7f05f648fb", - "revisionTime": "2019-05-24T17:14:36Z", - "version": "v1.0.1", - "versionExact": "v1.0.1" + "revision": "cc1d96bf3f70a8e6af1e436a0283ef22b6af3dd2", + "revisionTime": "2019-08-22T17:44:49Z", + "version": "v1.1.0", + "versionExact": "v1.1.0" }, { "checksumSHA1": "vNnw1bUS8Ct+8H64QuA2DWRJ9SQ=", diff --git a/winlogbeat/docs/fields.asciidoc b/winlogbeat/docs/fields.asciidoc index 3bdd2d9bd046..fefc60f8c86c 100644 --- a/winlogbeat/docs/fields.asciidoc +++ b/winlogbeat/docs/fields.asciidoc @@ -366,6 +366,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -384,6 +412,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -515,6 +565,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -537,6 +609,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -767,6 +849,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -898,6 +1002,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -920,6 +1046,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -988,6 +1124,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -1073,6 +1401,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -1089,11 +1429,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -1156,11 +1497,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -1188,6 +1529,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -1207,6 +1560,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -1249,56 +1614,129 @@ type: keyword -- -[float] -=== file +[float] +=== file + +A file is defined as a set of information that has been created on, or has existed on a filesystem. +File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. + + +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- + +*`file.gid`*:: ++ +-- +Primary group ID (GID) of the file. + +type: keyword -A file is defined as a set of information that has been created on, or has existed on a filesystem. -File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +example: 1001 +-- -*`file.ctime`*:: +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -1311,6 +1749,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -1320,19 +1760,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -1340,24 +1791,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -1376,6 +1834,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -1385,6 +1845,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -1508,6 +1970,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -1741,6 +2246,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -1954,6 +2480,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -2469,6 +3006,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -2481,6 +3054,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -2531,6 +3115,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -2541,6 +3136,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -2587,6 +3193,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -2718,6 +3346,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -2740,6 +3390,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -2830,9 +3490,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -2905,6 +3565,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -3036,6 +3718,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -3058,6 +3762,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -3126,6 +3840,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -3247,6 +3991,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/winlogbeat/include/fields.go b/winlogbeat/include/fields.go index 39b4e0f3149a..d370d8278894 100644 --- a/winlogbeat/include/fields.go +++ b/winlogbeat/include/fields.go @@ -32,5 +32,5 @@ func init() { // AssetBuildFieldsFieldsCommonYml returns asset data. // This is the base64 encoded gzipped contents of build/fields/fields.common.yml. func AssetBuildFieldsFieldsCommonYml() string { - return "eJzsvf13GzeSKPp7/go85Zwney5FfVh2HN0zd5/HdhK9sROtZU929s6OCHaDJOJuoAOgRTPvvP/9HlQV0OgPUpQteuyzmj1nYzW7gUKhUFWoz2/Zr8/e/Hz+84//F3uhmdKOiVw65hbSspksBMulEZkrViMmHVtyy+ZCCcOdyNl0xdxCsJfPL1ll9G8ic6NvvmVTbkXOtILn18JYqRU7Hh+Nj8fffMsuCsGtYNfSSscWzlX27PBwLt2ino4zXR6Kglsns0ORWeY0s/V8Lqxj2YKruYBHftiZFEVux998c8Dei9UZE5n9hjEnXSHO/AvfMJYLmxlZOakVPGI/0DeMvj77hrEDpngpztj+/+NkKazjZbX/DWOMFeJaFGcs00bA30b8Xksj8jPmTI2P3KoSZyznDv9szbf/gjtx6Mdky4VQgCZxLZRj2si5VB5942/gO8beelxLCy/l8TvxwRmeeTTPjC6bEUZ+YpnxolgxIyojrFBOqjlMRCM20w1umNW1yUSc/3yWfIC/sQW3TOkAbcEiekZIGte8qAUAHYGpdFUXfhoaliabSWMdfN8By4hMyOsGqkpWopCqgesN4Rz3i820YbwocAQ7xn0SH3hZ+U3fPzk6fnJw9Pjg5NHbo6dnR4/PHp2Onz5+9J/7yTYXfCoKO7jBuJt66qkYHuA/r/D5e7FaapMPbPTz2jpd+hcOEScVl8bGNTznik0Fq/2RcJrxPGelcJxJNdOm5H4Q/5zWxC4Xui5yOIaZVo5LxZSwfusQHCBf/79nRYF7YBk3glmnPaK4DZBGAF4GBE1ynb0XZsK4ytnk/VM7IXR0MEnf8aoqZMZxlTOtD6bc0E9CXZ/5A5/Xmf85wW8prOVzsQHBTnxwA1j8QRtW6DnhAciBxqLNJ2zgT/5N+nnEdOVkKf+IZOfJ5FqKpT8SUjEOb/sHwkSk+OmsM3Xmao+2Qs8tW0q30LVjXDVU34JhxLRbCEPcg2W4s5lWGXdCJYTvtAeiZJwt6pKrAyN4zqeFYLYuS25WTCcHLj2FZV04WRVx7ZaJD9L6E78Qq2bCciqVyJlUTjOt4tvdE/GTKArNftWmyJMtcny+6QCkhC7nShtxxaf6Wpyx46OT0/7OvZLW+fXQdzZSuuNzJni2CKtsH9b/vdfQz96I7Ql1fbL3X+lR5XOhkFKIqz+LD+ZG19UZOxmgo7cLgV/GXaJTRLyVMz71m4xccOaW/vB4/um8fJsF2lcrj3PuD2FR+GM3Yrlw+A9tmJ5aYa799iC5ak9mC+13Shvm+HthWSm4rY0o/Qs0bHytezgtkyor6lywvwju2QCs1bKSrxgvrGamVv5rmtfYMQg0WOj4T7RUGtIuPI+cioYdA2V7+LksbKA9RJKplfLnRCOCPGzJ+sJ5Xy6ESZn3gleV8BToFwsnNS4VGLtHgCJqnGntlHZ+z8Niz9g5Tpd5RUDPcNFwbv1BHDXwjT0pMFJEpoK7cXJ+n128BpWEBGd7QbTjvKoO/VJkJsasoY2U+eZaBNQB1wU9g8kZUou0zItX5hZG1/MF+70WtR/frqwTpWWFfC/YX/nsPR+xNyKXSB+V0ZmwVqp52BR63dbZwjPpV3puHbcLhutgl4BuQhkeRCByRGHUVprTIaqFKIXhxZUMXIfOs/jghMobXtQ71WvPdfcsvQxzMJn7IzKTwiD5SEuIfCBnwIGATdmHka6DTuMlmSlBOwgKHM+Mtl74W8eNP0/T2rEJbrfMJ7AfficIGQnTeMpPZ4+PjmYtRHSXH9nZJy39nZK/e/Xm9uuO4taTKBI2fLcEuT4VDMhY5muXl7eW5///LhZIWgucr5Qj9HbQMo5vITtEETSX1wLUFq7oM3ybfl6IoprVhT9E/lDTCuPAbqnZD3SgmVTWcZWRGtPhR9ZPDEzJEwmJU9aIU1Fxw0kFoeVbpoTI8f6xXMhs0Z8qnuxMl34yr14n6z6fecU3cB5YKrKk8EjPnFCsEDPHRFm5VX8rZ1q3dtFv1C528e2q2rB9gdv5CZh1fGUZL5b+PxG3XhW0i0CauK2kjeO3XpqPG9SoyLMjVpt3kcRpiqloXgERJmetjW92rEsArc0vebbwV4I+itNxAp7psrkDVP+NrrFtZHdgejI+Gh8dmOwkUWOyQnb0mOfNkw2KzDP60hNcLmag8HHcOamkk9xpYEqcKeGW2rz3mo4SoFD5UxdgQwXFiDk3OQguL5e0sqPkfRRaU4k3fam95jsr9NLf0LxO11Kb3z6/oFHxVDRg9mDzD/zrCWTARaxQUV3x71z+/WdW8ey9cA/swzHMgpp2ZbTTmS56U+GN1ouV1qRBzzJwXRf+UhQ0gYAlZ7iyHIAZs0tdiiiba4s6jhOmZHvhmq7NXqPVGzETpgWK6izQoppBP5MOijs7FVEHAx00QQCCwDxYah62uZkihR+1aSKiMIE/ObWtPUJo1Eb5k8qD91utcANAF0TtLhhRBgZr8Ku06w3pmTru1wGcsXB7jXdeHO8wzBOtFMCrUUz4i7AVJVdOZqCkiw+OJIr4gLrCCBn4N5GzB7niNLuWfrnyD9Eo9n6hwoCyb6WrOW3H+YytdG3iHDNeFIH4pApizYm5NquRfzUwROtkUTChvGpLdIumEc80c2GdJw+PUo+wmSyKqHPxqjK6MpI7UaxuodTxPDfC2l3pc0DtqMETbdGExHsjmymncl7r2hYrpGb4JjLspUeL1aUAkxAr/AWQK3Z+MWKc5br0G6AN46xW8gOz2tPJmLG/N5glEQE2i0YrWAhm+DLAFOh+MqYHE0RZW8IpfwFoBFheo80Cb6CTsawmHpTJGMGa+FtcJVROKgbqB1o1QMB1gnYs7Mp05YS9QaQUOqr6eLNof9bah7/4H/BWEQ17tB/+2uzZAd4GuuLl+OlpCzBc1A6EHZ1fHH/cmnMu9DiTbnW1I8X0uXQrmKq3+tdaOSN40QdHKyeVUG5XMP2cKMlxsh58P2vjFuxZKYzM+ACQtXJmdSWtvsp0vhPU4RTs/PIX5qfoQfj82VqwdrWbBNLghj7niud9TBU6S1X6deDMhb6qtIx8qW2U0mouXZ0jry64gz96EOz/f2yv0GrvjB1892j85Pj06aOjEdsruNs7Y6ePx4+PHn9//JT9//s9IPv4ujs2/c4KcxB4cfITansBPSNGujdKYD1jc8NVXXAj3SplqiuWeeYOKkfCPJ8HnhlvNkjh0qA0zYRywpDiNSu0NkzV5VSYEWjyC9moNTYOiuAVrFqsrPT/CJa1LBxrm4Dws3aJ9wDshlIxXjtdAgufCx1W29f/p9o6rQ7yrLc3RsylVrs8aW9ghk0H7eDfn6+Da0dHjWAaPGn/XoupaCNKVjfAEF9oE+f5RRTQgSOCsEgpC40AWgkve6NJ+/zi+tQ/OL+4ftIoHh1ZW/JsB7h5/ez5OqjTyVGlvYWob01ygV9/lGA/acOhjbu9vmGdkWsg08ZtWndthRmLkstiRyzNczQGE4RtGABgVhfFwOG4UyD2LfPTwLTAx/g1lwWfFv0z86yYCuPYS6msE6RlteAFVX68M+tr3wI5I2s7TByNJHBzPKwK7jwhDOAV4dwhYlP1CCfrA7HgdrEzeYmY8vMwP48/bJk2RvjLasvUP8NriX/RCxql1Sp1HOJZSjjZOyvIjDmBVcgcrxPwh1/dJLqXMq1muFe8aM3pFZCMq+YazYI7uMP6aIYdsL9fOpy47pJW5IoAQx+qHYmsy4VnTKh7gOtHqj4gyZHkcCRbtjVd45TRtBYerLesYRQIQ/LIA2eGoRiYi2aGR9dw4/TCKzJajAPnBbsxW+vkmrHXwhmZofHZpsZtrtjL5ydo2vYUMhMuWwgLqlcyOpPOkl+xAdJTV9sd3vJrShuNpm0QaFxTK3JYGlFqF02sTNfOylwkM3UhQ5g4I49aWFDYdNV8Smpj23OPgzYDgeuQJg/S0Q8rbQMqIew2RpQMLjW748z7bxsE4VzgMjVzruQfeOhlHt3gdMpWLJezmTCpIQWUYwnOX8bxeB44obhyTKhrabQq25pVQ1vPfr2Mk8t8xH7Uel4IpH/2y5sf2XmOjmowo/YOfF+dfvLkyXfffff06dPvv/++jU6UkLLwl/4/GlvJXWP1WTIP8/N4rKCBBmgajkpziHrMobYHglt3cNzRc8m7sDtyOA9epfMXgXsBrOEQdgGVB8cnj04fP/nu6fdHfJrlYnY0DPEORXaEOfX/9aFOtHJ42Hdj3RlErwMfSDxaG9HoTsalyGVdtlVno69lHgMXdqnqIAcIE47D4UyDsvjSjhj/ozZixOZZNYoHWRuWy7l0vNCZ4Kov6Za2tSy8Ou5oUXRz/MjjlopjZPSE/SCSWw83OLzii22nBrkbejFzSRhPJTI5k+HiGKFAmz35pch0r2fpIEkAprAizLsQRZUokCCvMKQ1Dm1JEqqVR5CTpbiFgNqJjkdKcLN4mbfPsCz5fKc8JT0bMFm0lyJAS27ZtJaF8+J8ADTH5zuCrKEsgovP2wAkUaGbZ0+iQzfEh3aZLUxKoZateXe4G82aG4tQ5CZIsrtiJzg6K7nic6+9AT+JdNDjJBiVmrCRxLWWMpIXnccbWEny6mYXLGrPydtgYkU70GE7OnNgzMTrepO/FbkP+Vu/RIdgy5+5lVewUWMxoPuOvIJxWPAO/vf2CqabEiyIFLnfOUSfzTWYHoN7/+C9f/BuQLr3D26Ps3v/4L1/8GvyDyZC7GtzErZAZzv2FN5C2H8+d+FaDNz7DO99hvc+Q3bvM/zafIaYKN5JFd9kTXgtHD9IdyfYGykVHafc5jZ/U3bCQIr5p+VvJen3oJBR7K+GxVjm9JhNRGbH9NIEs30CGA2FgxvPE2VZW4c5T3AYil7kN2O/+uv377UwKwhlx2SvSEZS5TITlh0c0DW75KsAEGT7F3K+cMWQtyxZDXxPBQo8aIWXplI5MTcUYc7z3zyoQY5mC1HyDv5ZKwvX9jXI4/HR+CilHGN0y7T9Mj7YnJDamJYzyF6iYHgcEM4RVyv2XqrGjPEOcxFKzJ/C98CcjamXHnmFQN+sR3NIQwUelXErbJOzGZYFey+dFcWscclyhaPfwia1I50ZkAmDh3sD2g4FAdjWTndoQh+QngMQpInu68GIye6Diw1p2ymNXXeShV5eb5n0jPs75DoJiQ/D3pNCByUQvSxGZi1aiST5DPLo29lInnwCT/EE5bcsyTMGc+AC95E3acOBSb9q8v2BsYQcaEjCkaXwN9jgkvJP/UBxjCZ1Ws+SRdB4YSgeUnEZZJuG6AuKqWhyp1ChZ1OBKVKkl9OYPNhvnWY8VYlHaNEcSMCaCrcUws8UMi1UToET0TmJk1HuEiZTZ4X2Qp49CztxM7rxBkVDltoIfw0HG1MBI2JmC/yZZqQDQMOITl6jYZuc7hbWU2ppUF6KUpsV80wOMmdouDxBfENw13WhhEG3v2yS5ull65UgkWPK/G0iQLawD3105AeOzjJeYe0ISpdsewsoezZaQChNrTmAMikJM2bn4KeE3Wu0iwVXbIIvhPykSZOKGTfCn/UJIOSA5/lkxCZE8gdA8gIezWQhDjIjPKFNMKknFHCJI8ZM7UBxtDLp5ynB3NMXkl7pOqi4tR6ZB5i31RYXBPoutuMlHgaaoYv8KOQWcr6gRLVhHggcEgTorLcrcUzYHciL62wOEsRkFPbUCmUpYayxXvEIZoSrGTloRzykEP7KjT/cUChhVkMgWlR99MyrQiO2FKwqONgKKAiB8ThkQVU5eJaJykGyNMUloEwLqtOIVViOqbYCXVUZr4cNarDT4NRrWEPcZKSsG/Y4Vkrq7iMROQ7SC20bLqPkeRJUFoprNoIDzYacdExqXWH2X6+2EBEJKpD+qErP1jMyyDTVoGKOYPKo2VaCNY4ZOepA8aZYVKbLKs4VK7V1SdYiWFU9ES11U3jJoo9tKga0ZDzS4c+scV1l7fJDGS8y8FOSdafgqyirAE8k6ahiFKjwJHSa6JWW6IBtgU9D2RVjXZC6ImeyUxsgQFJqJZuMXZYMsb8PmmzYMf9niAtzmr0XomJ1hcQKH6Vlq9pYhVx1gLSNR88yUc3LeDFKd7ZxGg7ctnPuuBU32do+ipOl9hCappPKn2nljzIa+Sf0zoQ98JzdCscOSRxb4R56eg7mcixB4ZUHZutpAz5cf0qd14WwwOpaxy7lk6gZ+B2sjae1YhWqTUnVTJpe+JFEmp9wGr+pBC283Gcx1nHXDnzKa7ONs2fAvtn5UqqqdlfhR8WVtiLTTRq6rl36ArevZVHIwXcqIzJpYd+OBzfzBU3dEiceWcm07XoTyBFAXgPq8G/hdUYj2HullyqtutZQqRs+9eFIw+wK7+44ehKrFO8caht75Drm3YDa49tdlg2DeiqIz73Au079UZ6rF9zLLqxA1Ali2qFJ8CduF+xBJcyCVxbqEEF9nplUc2EqI5V76PfT8CXJDKf9BoBodTouIBelVtYZv3y4L4FVQrrVgBU/RIEO/evZX56/+GxX3vMXfjUxRCZRZzswD5aoeS+3IqCPVrj9+MMV00iGz+U1BFF3VbslqWDdsL+EJAPNNsItVIGjq2Bi69ugKXa0cXg6acaceMYmvB7OC27KyZep4AGQbSMH8O1dyzuSDugy3liZBysSpbeo1pvJaF35p00sudVfeLmyv7fDRoKqtoulv+FLsAvF2oJ6Bm5wE6npHalIG3jJGiVWaS9ncvFBIM/PdXaVxCPn0npKyVHeg4MB1EnBTbYQeUOw09oxGas9GS/IxXXQZSdXqGtN+pi8FBU7/p4dPT07eXJ2fIRRxM9f/nB29H9/e3xy+j8vRVb7BeBfzC28yo93CoPPjsf06vER/aM5mdqUzNaZVyxndYFqSFWJPHyA/7Um+/Px0dj/3zHLrfvzyfh4fDI+sZX78/HJo7bvVNcu07sL1fDsi6ZYx8FatVcbe4G/xGRoY2oOs23L2NbISUWlUN2msdXgi8SdCIVUB3TGZVEbMciT4ohb8abteVIcd3vehDC39s5I+/7KJody3TGdFZoPmmHfSPuewQhYtE9qT5xtte2BGM/HzBLhMqsLANE+bEwx76ygyxM4VuH6Qlc91NcWwnRDcCPsV0qbcgv6W7uI/Z/BbiP/EDkMe8OCRtG05jXyWVzEkd/L46OjgQJwJZcKA3DIs7nSNexZiRGaXIEVkooYwWWZWyvnyiYA2fb90Q+x5JgZbYWnHtUsA7FGviNeFKFEU0dxteJaJNFMdxL8cEljdkx3cUPDnB0F4NcFRls1emC4mTdf0FkoBVfAWa+FSW7wUWf3iAUXjufS+42VqK6CEpIY5OAmzd8LBqZWmkqKkKyorLQOzM+Iy+Ct65yu/e86iPVXhU++E+CF48ZbAVkp03tBi5P5+0Fj7VlzMfDXmh0mp+0nYra5fCUFVltL2t+3jbUhrS/KSECTm4NgbmuuhRE8XxHbycWM14VjlyvrFYDGhJFwn3M0mACkvMCMv6W0qSnkWcOQ46Q4JRDKGVgnlVbgJTh/QZPvvayNrsThs9I6YXJe7j1MzvB0asQ1Oi7C65dv9x6CR0Sxn346K8uGuCUvwlsHR4/Pjo72HnbO8q4qJL4RSC4ggkjTrtHrFtdCFen5tYa8zZiz0FQdh/APr5uO0wrFM0nKMfnqfgh/byzrBzX1O34dZoXrX1LAZWbZ1HOFtoWVXE/+V/DGB4cJmFeAVzYl+/x0VDs8KHTcWp3JpjQwqGmhpl+r0JwdeW59SJabwDfQ4QMb6tUTbQVVA0enAUx5HpRV9hotfR6t//uH89f/FSqH28ZvRZm/UPwPHNuo7QTVop+zwWczgdZV/3pnPYFqkpL7ZIy6jZt7yxSZdTzwFQ9F7wHEUjiOcbPgIumwr1z45e+Ieb2Awddkw2GadtFRT2DufqzK3fFT2OU4S1fniAkhhV4ywe3Kg+gEkNB0hQiNHw9EblQk22N07c4i7i6MhILuGF/nWeeP5y8erkdsQ3O7hiXN7O3DIVUviuMOk4t1LtqdKQIQwUWW8inWNjjsLMHYA5Xgw4OiM8eLTnXKnnJ0evykDePdMgayKIGGU+pczmSXOeil2llCM0oHP8E+mExMP1uw4m5XNtcL7hZBqe3TqJV/bIPndVHWsDQ/ht9pSLtiD6KhRPsLDc/zoLtN/FgQ/wau8snDjnrJzVy4qx2i4i3MAMgGjcOuykKq952g5x0m4AO6wFgKLqURy6UBJYMg6WCk3hlLfUuhnMBN3wE3Nc39O4nOenDZYbVIyGk41VzoVEH7kf7coJ/9KHQarJdx4y9pTX0V3piEQ+5JWkqGq1RHajf4SdJVWooeKWW5MDLa2JzIFmCbb1oGeMjOL5LYGXRSmgNbV1Uho7dyK+Xmy8nQ++Kz877AzLwvLCvvi8/Iu8/G+zKz8b7ETLwvIAuvf1kI8is+WC/B3sZsnyQWuBRkam2Cz+EdCiqHxguiENc8Hk7SyhI38MeUNvmiMps+dzpTDFrQthXS/VP4e6OZKBTgaZmJqCw/y3RZ1Q7Dh6laVOwo9fwS42VDW6hhg2XaEaoxq2D/p6YQUDt5IMReg1oIaspg0HAaLuzXCniN8cE04oKbfMmNGLFraVzNi1DoyY7YC6gIklTbASMU+2s9FUYJB+2BcnGrOhomW0gnssSpdafJUlUIlguNHJL5euf8w9MnV0/a5RruqybcV024PUj3VRO2x9m9nnZfNWH3VRO8/NwRJPs/0dhpdcQ0jsQlrfaCz3VJbmk2CZBNvO5Q+vNrhKsNloLtFVvc36jV3WmLPdRz0gJOz2zEY4hpooYxmIQ8Ahc5edOj/upVXKnmEKFAAekbi6iipkwhzegS9JidQHs+wFQXCx9XEQM0IFkNFzHYTSWLn2grh+fcFX3+vJE2wZhGee9AlQlFJpT4DoqDYbQHMUmI9Pq95gWYxuOYVFIMqzJgGp4HgKxzTfYSZIXDXlsvSQzLRSZzSJD1uiuQUcPYtX+/s/Hajme8lMVqR6Lpl0uG47MHwdZnRL7gbsRyMZVcjdjMCDG1+Ygtpcr1snH/N1X04M0e3HWxq/ocPZ2X6mOAlh98PiH7PGT2DqugPPM4eK1/49eiu4L3XuX/bGvA2SLYcOcyfEnxQn3X0Ph0fHRwfHxyQHlhXeh3qNCswX8IX06wvw7h/9GFNlybPxfEYT6ie68baTti9bRWrt5E69wsZY/WB6sr7A74bWnk+Gh8fDo+bkG7q2CX0A60w35/0IYqg4dqxdSTljwPrTrsfghoajyJFZYnUEj+uhwlCjBEXie6brysj9KWr0kN8tTj0cjqOOKQzB6odXJfcahNXfcVh+4rDt1XHPqyKw4tnGtZ8X96+/YC/r5NjxL/UQyHHYf6MGxSm2ISAlMFRlMnXTUBSFMEeKkp7vb2/PDBVOer8UDF25sCMm6senvZis9og8lg1i56nz79bj2IFEyzozP8lq4juBkbofxJFIVmS22KfBjaHeDyrXa86ES8dDD6wAMLh30huNcD+srV8emjYQSXwi30zhL9WijFqToJ0EjkmBoA5WKmIs0ZcJoVeikM5Hx7FhpqUI3ZpaBEWZ3VZYjzimNbKtmydx7C6r2W9/L55V7fPDYXbsQqqB1T1W4QTdAi2uwsYOsNDd+k1KSY6+2m5z327PBwWuj5mJ6OM10edmC3lVZWfPZzjtNue9BTID/vSd8E5/qjHuD93GedoP24w05AW8ddbQdMvduCvj7Fpo1TnGjY4nt61HaT7faKB3CtuzMfj9NOJ6HeFEn0V/TnjQIdbU68VeZHQ25nmpmzjWSGxe/iDvlLyHTyUEUvCFUK62UvYgeBVvLzkhs1GbEJFE3z/5ADiaLCmNZydplwG9LYWnlcfjEhAZd3ixfA0U/eSHTiGdZoKqRD97tjNZSIiWprxU2rHuI52j0Nb8oRTmjYoLghVaQWUmiCHwrI+BHTTL2wFzRKmiDayQ+lxY56CwoJwHHMBb8WMffI+k3FWOQs1FPEEEO0DAiVaWyWYJgSS1ZIJSx0k7tObin+flMIriBxrQ3yp+YvM6spPXl/H/QAL+tT4/A0WMBAW/jkNGZwv4Gj4vWKzn60pmO2TMoNfk4e3VC0L+TatOM80J5SlrUi/GNYsL4WJnCQJqiE4S4kOTsUp2HT7kbhjY+KCgmjd6p1dLOIQqGg28RlVNiZY4eZJs/w6jaX10JhhG46K3G4yminM120SxVxM5XOcNOY/hkltlI+GZQktHgoSpkZHfKYRkCBvLAaJlvhyW9etu9XlWjMaTL7fcRmPBNTrd+PmFtK59BrIS1bphWJPKtpykQ1RT7ZtVB5Uk0JQqaxm2IML/YiNo/hxLFgAp6Cw9wr3ucXGENtR1BV3I5YMuZSmpA2+AWq5ly2O8HddX+WfVS5UNVyhisLijjsyFT7cyONoPptrez+CVWmgi8p6T4tqx6eh0I/IzYJh5V+Qtklm52wddlHwKMnT1sIIA7iVle764T5DE1ZUOoTMsqAaSeF7M8vsNIkURO3bCmKgphcXE84fk20Qpv/jWMqOmdO6+KAz5W2TmZee1Q5N61Om3HYWaGX6Wa8EtwoTFrnLl6N5tIt6ilcijyBQGm1w4i8A5kfeF1toDzw2eKX/2F/Pv3pf7z+8fHrvx8+XZyb/7j4PTv9z3//4+jPra2IpLED9WbvRRg86GmBXTvDZzOZjf+h3gi/Hiy/1IjTs38o9o+InH+wPzGpprpW+T8UY39iunbJX1I5YRQv8C9PQc1ftQLC/Yf6h/p1IVQ6ZsmrKilQTP1jvfA6wJZ6ZZMcSnVqR1EgJYpNOmbkXH6YfcsgXskv/lqK5RhhWDNxQI02rBJGlsIJg4C0gN4OpgaQFgT+v+DKoMnSkeOk470uORHuW3Qz02bJTS7yq08JPkhacsQ8dTquyU+kIFdGfxioVfX9yfh4fDxuF0+RXPErDF/aEYM5f/bzM3YRuMPPMBV7EE7ucrkcexjG2swPUTBDbdvDwE8OELj+g/GHhSuLJIn+kvgIyKtQxyR8ZYn/8AJqWgAHA43nZ+F+KPQSy6vBv8hiG8ct9Dzc+moy2Q6tqYfwdsrhrt0iqBxNV0yDlxOKjesgfW0TwhbkUhfaH8Fq96ucyRbYn9YlhQQuDfJRIpe+HRC6zS8DYjf82OhnJICHBe9J20gRqGYXV9lX34XbRSMzIaaCiQ9jkGgjVgBF/cYzr0l6pHnZ22i4X57mFv0j0T0eoN4FCi89wXMbaTlhYqi1gyuVN4UgBPsrzpMew9g8oMFwwVeeOdV5NWIuq0ZMVtdPDmRWViMmXDZ++OVh3mUdxO8oLuEchc4vl+eQhl2gEF2m8QOBrF95LI497k4Rg8ktqbIiG7FKloDQLw+dHujENECValotI35Jn23K/1Dx836tkEpkkheBgkcxORbj4HpXaiwuEQvv5sKJzI3C+PARVhe5ecSDtnwj5Sop9trOeI0RIpxltXW6jGkfOCi0IAdvNy21U/NEq5mc100rEqeZqdX2CGBWz5yfLqmF1k5DmUkjlrwo7MhruKaGkB7EkNTqsDKwRBgqBCUGHTLREq1QVptY4Woppi0okkkgCLzQ1rKhoT0in128JmzYtM1qoIbUgMOxGvQa+w0xKBwcw0jUapRWisN12kgKNtR6QXKwjcK8AcWhwgqNSXVW2Guyrf5eixoHZi/fvoLEJa2AasJdj0pFt9uYEDkFS5MRYBqEgla5gP4AhA/oCPvy+eUtjE73yTb3yTa3B+k+2WZ7nN0n29wn23zVyTbdXJsofdv2j48zyvRbpA4P/9nanLYU1fush/ush/ush/ush7vPerDCSF7s1mAc7tc0Gcn7m4po3V1zsNBtIGWrsanLpsL2wlCyo78YBs0pGKKbkVaVsOOhqJvgKjBp24Fw8YQonNzCfypLLcI+rOAfuigEhOngJdb/q7mCDsRGhDFbKG15n+8SqXHlOEMasz7uQLC5t+odkFTCWJqwpTlX8o9G2Q9mnu7zG+JA0nHC/V4oI7MFEg5c7Nf1LisrroKU1ob01RbRdSI10sCQpjfpQhQVlOXmxnA1D+16HFW+TXr+cIVBOuAxaEftRzCa9dymTse/IE8lBfWz1YtJ6SOqBw1Xb5FSZMGXwIJvIKe3YGfttAtYQzq6w923jz78KjXDr1wt/Ip1wq9IIfyKtcEvXhVMPKSxmQdxuYvk0dbNtNcyt9j1d1jSZVw10q7JwSObc7v3HQQ2xibCMj9MaJmCSlpxtcCAQwfWcQW5eDMnFLOOr2yofxy6+2I3bh77Z4GCWEl01ECmYqGnvEgq0QdwG4PSdvWv5ttkIHxcDJgxfEXhEoAkbubgSEvtZK+hzyTpE7i8ymgnMgfOE+nkdSsJsqd30p8HzMYUzQN2UMR/1jbeKQ5YaP/TjqIQH0RWQxeEHaHi2RS6wwgM16UdDFhpZu+dkMPamsOpVIdhbZ+jbiWdOJJCcaP81QLaTLCMF4WAlPG54WVMgLSylAUf6ATcBb66MUv0VlkjF/EI9oXPyWk7MKnqzf3pWSsXHArF0Hbu++UNAdK58n5iI5W3octqSknUMKXvCjg5On5ycPT44OTR26OnZ0ePzx6djp8+fvSfnU4bCyN4vl1K+K0w9BYGZucvbt4g4Pq7pmyYpBPv4nEIz0eY5YCkDn5Sigup0nPBnnOFYdzTps+mO4tDJqUOGGdTo5cWbA8hOYSACLxgKaas4nORdFLV2M2+vUVLbd5LNb/C+KZe8+w7TXOjuVicK5gvogjtcquFLsUhL7BhRZM41gQGkEx/kzzaKNOb1joC+6CHaqUznslCOi+cK3mtsR2x0TX00q+kyJIOVtCdJWw2GEjgBdttq0Lh8FYIaMJecrXySlgGoQH+avvy+WXo6vQ2BYGGxmZ5YMPBG2Q5wqsxZBYEWQhNq/wUoUyVJscUyG9baZU3p4jSXxSbEBbHk7iSZ9D41wgXDT4eQ40LQdhRkj80FayGIkfQZj9aT0YU7zlqiCBEwo1YVkhoCxZe5SqPwVFpACoUAQH7QFVBT9miYOcXQa1wuoFeVpMR6lYc1B1FSKPKBhhteH7BnJHXkhfFasSUZiV3DhJcRBQT0sFk3Ih8xKarGLSTTnXGx9NxNs4ntzEzbNOCY9h586yI+XDnFxb3WKukEXV6k+/H/1xuF/1D7w3kBRHxUG2IGIySaaUoUmkWDXEUTmHEnJsc41SsxfbizfsW26TLGEvp1U0MZc20SRoV/6ANe/v8IvYFAqYZwUTYMiH934QgqSQUmrj8+88UxvnAhoL9QS9/fpHAMoZJsF5MDL7tzkQ1cItVDx9h+9ox8MqGfojAFSjYhvHM1cFpi5F8wpRsL463h+WSZ1GtTKFQHcBtqDAGP9M1I/iW+xlVgZVQsdgMGZvtTJGugxjSZWsCDr2sYBU0YhMKhMU+fqtV1txj8KTT10ODNahtCoE0Q/rTi9t4gA77kLNKbz7H4Q/DEtp9VfDaxXPP5UuunMxCcD1lZYkP2BqJ+FlzI/JXtVld+NeupV+u/EMk5k3FMmHgItgkRgVeZeIcM14UgVeFjv4Zd2KuzQqZFSXEWSeLggkFDfXgtTWpLR5hM+l1ZBqWV5XRlZHciWJ1m8sZcvJdqUPoLMBWe7gxUXRgUmVgMOVUzmtd22KF1AzfRFVn6dFi4+0AXBPcs/ER46EYHxaugRJ+2tPJmLG/N5ilIo5pfRI8VYYvmzQEpPvJmB5QjmxbjVNeMjQJjHmN4Wh4r5x4+QMFcMYI1mTEcuFFFqSshuLWTbNAkDOy21zyrvPH/gKJY1B6vUm9I68O9ZaG89O3nzxtx5fjom6A7KMK3SA0OH6nbdV9yNx9yNx9yNx9yNx9yNxXHTL3kRFr+/2QtRCw1lAWXj87/mB2fnF96h+cX1w/aRSPjqz9bJFuQ2F2n5aldkHpaR8j2DtGy5sTnm5nsNRQNmTtuu/rad7X07yvp8nu62l+bfU0qbAJvJeY1cKjG0KtQlmUrpHGpb9pM9DiyCtIBNySW5bpooAe1DeEU82kyqnEVKBOyApHsox1wMLc/s0QsbC9DUFUC1EKw4sdFvt4GeZI2ZMmrTCA/0DOQAeAtuT2YbfSk8yTLhVg7rGMZ0Zby4wAxxbVzpnQgHD6cg09n1xfH3zKT2ePj45mbS1nF8dpv8+aQ8G9Wim0riLE/SWTqQJPYBGbmK5aqKMiAyV/LyyTjlXaWjlF51EknTg0kFCSeIk0q0SPoIY6XwRDvvH7VAkjhcrAYWVtLSwaC/1YRuR+AdRirLHpoxs/jhua1cscywY0oRRwDwvEjsY0qebQfJnalvV2NH/0nXgspjNxxMWT7PT7707yqfh+dnT83Sk/fvLou+n06cnpd7ObCiTcfU+LQOFNJC+d/4Fg3vRqFT+E8F6ifZBG4AiJtSUKvbRwyVrqiJ7mjhXGgh4XgVWYhviCYuB/j7Xc8RqoWs5L2apPQU0y4mkD8Zb2Yimw1BqB57cxl17nnNZ+5aHeFe6tqcEXEiXOQltnh8kXTffBVE2LZVgShpbSCUygHHJI4NYz9rLg1smMHEsJmmEJlHkcxDQq4bV1wrSuSujU+IvgzvaHkNZjJxczXhcOKhJV0Tca8eWgbTRw5DimnDGlWRgjNiQZKIKYruEgTXlN4gfcTiw01PYGxu/Q6b8mWP5Wpws+DP5OSmtH/XhAzraYpJfowCUThSGsZA2nhEGalGQ4dW3o2sQ46lBHHDTWO5i0Nn6oOmb6e2s7dhfmvv+3EJ7a3pDoaGnpPP1daXgY1FrQ7xn3pwZDx4XDjusdnee6mZJH8usXNhufjNO6CuiPaal/zZMN2h++dbN3Ljh8ACq0Dhy26562R0rccDc44FL3EXnhvkg3ETm87t1EX4ibCPeDrElpGaOeSemz+YoQpHtf0b2v6G5AuvcVbY+ze1/Rva/oq/IVYTW+r81XRFCzXfuKtpfun9FhNLD4e4fRvcPo3mHE7h1GX5vDqDbIscha8O7NK/hzvang3ZtX4XJPHTOZrSuo8ok5eH4iB+BU3MBevnvzigr40ZsxMH4h2NQIjkkWeqmYVE4zmy2EZy54gxpByhh9r1ng/duYBYaueHd3aF7QjZ3QbYpRbCCwt1wux2SpGmd6r22rheyajIP1APBZ8hWGU1O4r1cTsNog4BXDz4tVk7rL20tjlJEDdmDo0WDFiOLwm/rWoLLOdey0Qld7sg70VMT2Elp4nRk+L3fXYWrfS9vE3FabgvGZo2ohk28nCaKdrvY6FtDJt5PQL4Xaw6AWTkB3eMYOM9/PZygqPf2DnUiWfj8pgQdCsGsrmt1aJQYZrCgR1yUVtDMECT8ZseVCQCKAa3WIMSLTyjpTgxXSUw/GmAeLUNsalaoxA13R2tt/dnr66BBtrv/2+59bNthvnW5Xyh3uV3SXwgr778AaqWURkIiNmUtxtX39+mftKHZdqoF6paO0PE0eTyfUaQ2bOcJEHG7T7eEZpMYVek63Pv+ptJTh/FttXRP0H6rVesa2tt9PzPSKn8VhOThBl9xGQEctxjvoDv6ojfWjrfm5o/xbm+zkXe/5BQ0/2KyzgcHtSkG6gB5DrbkTHkQI2hvfcAW5g0Tb5BrSg+P09FE/u/T0UQsoyBLb1cH0zBcmICKOFg6AF3/BtQ2uIZ4Dj9MOsfV4/L8BjxcfoGBx0m4inQUyXVDCxt5fSvtv4YQmJnSsLpXADp+6UHmKw3zT2sW3RslkuFgM6ogjxq5PZeUaeAB0fHNCX3dcdS1fNJsKtxSiEfOQi7XUqDx0BBlqTbva20sYff0ZAO6y1+GzmEU7ORuUxwjvGj7VU6B3fKtNYxIS5pJC0FKT7c2Jim9JB+851YYLDsGrKJegubG45lFYk8bWdrT9kBTs4NdoMRJgL04vKv6JFJaOQrjgYaMft+AKPpN5yH4NKn3M1yVJCccMvJiEpfI2AVj/QrvIV2QS+QqsIf9qQ8i9DeRGG8gXZ/74Yi0fVpgrPg9XooSzs+bpFvwdxwhcvong9Jd8qoIUil9EyULAvfV3PiqBtNBLape6FNMYYQIBNkldTKw+wY3XFuoIatAvtmfJ2Pfic51kmq27JfJiEUIIPlc3p4RCEHU9oC75jBv5OS+07xRt6HU7yqghrgFv/h+yKPjh4/ERe4Bo/J/s+cU7Qin75ZIdn1wdY0PNUMvtIXtWVYX4VUz/Kt3hk6PH4+Px8ePITh789ae3r1+N8JsfRfZeP2QU93R4fDI+Yq/1VBbi8Pjxy+PTp4SnwydH3VK298WxB6G+L459Xxz70yD+b1sce7eg/q3PddeIBs8Fvznwk5yxqYBWQVxlC23wz4NMlyWASbrEX/Cd1mz/CwZ9HswR+Al8HkMmw+UBlMuCSolQeetv1sQ/Arydpg9DKNnYyYFW3RrZQzZ2shR/NNF+ODAvZLSAVtwtzuh+2nm5lHPDcT5natEeHdfSGlZPfxNZbN8Nf1zduJL/FaVYxCzsY+iSBeikqNI2BNCJvwVAozitneSl/6hTahPK1OS5pDJBXneHOFeKyYd5YsGwdA/ZcET5uh3cAFYDWhKy3drIHnX0N9ETUfrexv2DQQfJrj/wII1uHB3CZAWYL0IexLak/VZiLogUTY6OvxrR6c0KXefNQX3u/wy2D4hm55TQNoDp1/Qr6uNZ61PrSUDkIXWE5/kVvHAVhgyV47RJj3Jr1fDBuDLak35jDohciH45+LCZRlN1lz7x9Pij1vNC4IqRGgcmlyWfi4GpeSkP+DTLj08eDbLSZvZzPwI7fxFtDIinmNqES/6WPfNkgvlZRZ6ygxjSJBwfR5QAkm+gs8GXN9JZMkcAsEkV3DxNXFB8/9YzbXF0OnNte36S2Sjt6SphMJsnow/GyQfbzkUCTBbSra62EBubv9p2VqLxbTeud762nQfjELeao/Xq4PiBH+U6ew+0SgzpRfh74Hjhb5Ce1E06od/8ubYLbdwVyr8zNuOFFYm6gvMdRGa0Rq2IYLFB6bhOipFETGNxhpGVIGz4k0GkrZnKc5zbzwacTqXNa281a+fL7Sb9+OkKPhWF9Yzz7S8vfvEa3JI5zUpeeSZrxb/1YGmpU2yzSsU2qxbI0xGEcaBcL88buv0J/xoY5NzrQwm1kljwn4eczHFCoNAFf4g8SW68fH6ZphjJmDMkMjtelcWY3sO0c24oUFurg+bLjmkZQd9M6eu3pmX/DUNMtS4EV1uid9ZgBHyOzbb359V2PK1l0Z+yv6NReu8dP31xfPT93nbg/HLJYIZ2W5khQDKdi8FzsAkW64xw2WJ7YMIsoVtrpMD39VQYJTBniOjwr+mzgXGb36Oy19bcmkFZSoWbuWrz0Y2ctQX0ZprrYrzS+TDbudVhTjBQaWrfPThVPcDDP3amC52zd+cv+hNBbkPFs7tbVDNifzKd91j+J04WjHX9yYhd/umTGXPy81XJq0qqOb2796ctT1ECMQmSkld9kMHLRLVCvzS4E9iGgTcCEhmtcHe7xc24azY6F1WhVxBgeKcTN+OumRjy1Gd1cedLTgZeM/UNetDHThyHvXHaYaXv0+fFcUnANC1Zeg1ZBsYNFfajXImX2iE5kLZ7uY0QEB+2VTtDqfpehw82oHrSin/ThX4v+QGvnc6lzfR1ejn5f/FX9oJ+WbH0PZbcvG+0ngwMlUphgiMOuc78Se+N0cTUNhffwnYYLMGYqcf0LAKQ2IOH55Sb7NDrrIg8W5D/dgFm8ehVb1etFzIU/fZIyFleY2N9x42rq5bxFhRhbUpMdozWT4ggqLjhpXACyjdNBdgr/b5Bo3uBEW/4wP+JAW4yB9CsuIbaRhU3zmJQ1/nFiKWNN2Q+gqgJ8Fu1QOIqx24PYJMcQiFV4KuMzuvM3R6RbymzGM8uDePVxLi2TdN+NLm0pt230cXxIJn54Q1TJ60hbzkzNX1MEqtx+Qkt2FgBp5uHHuAI2R+3nv3dm1ds4S+fUNsCpiNqBUg2IT2rTcdr074mrZn11xjyHtaHRTeQxOlKyWu3EMpJTHsNodCBrS2lKvS8YWR7v8KDqeBub5hbUYxdjLz4FX1s7CW4ZF7p+VorbqHn45ksxDiJSh7CsRG/19KIvLlN3ID51GHjJ0hi3ZfgCud5KM4mFGtWyGQjG/xLTV+TYkVxKoqNxbX7AMN23STg2kkSgu9kLcAs0BQgbdorjD0ImMaVnb94OAhQJzLDi5ClkU6QOLsRAMOX7D9ev+qU4w/oxbn1FE4WYZXgwspUcawYtA+VXBoPnh+r4wm1IQkqOP1pxEYsBNpizy7O2YPXMjPa6pmLxPc3af11FVqRLIV5OO4kDqQxYhS5mbfKNamclbV1IFuUhxN+Dp15JvTN1YeyQDw2ZXq47YkVXTUxcdD7VF7LvObBbenPQTt0+yZ8S/DdzeoCKcPoeloIu9DQ4iaOVNWm0lZQc4nQ7QAPBZxZIzyScWnJKYhcqqx4mmATUoyTgTygEJHN50pbEHXTQpRdD2LkKuw2LsRnRREgjSV/CIYek2nVmFkII7puxP4VrpKJltecy+RUbIAt7FTcQaBEKCwVwtSBzWCwdKZNjrsQq/JRYx9uRGvMvaVUMGah53vRBNhfrp9NG7YX3p1L1bzfGjF+41/x3yW0FlbRewf4ZC6snCsSGwEEqvJ/cnT0qDVM8srJ0dFR/0xD6l3rfI4SiqYltIaUamY45mrVRhDrDkCN2S+d4SDGkYPyFuZuDUdwjDZgFM9VPk5PA1WLwBoSrQFRgbGkicL+a8hW8/gK8iMuzw5YBnnm5LV0q6utDEjDsuMGIn1GPSCLVT8iNZRdpL8xB4V6i0XYgG5bQ1JfIPjYH7uqnhbSLqg7NAqqZBJ4JU1qaN+DWTPT0DW2rGonzNWWl+ePPcaqVYAH58QFYk8bKPqUHOVfveJQW7/BXdkUMcSo+xVlzEk0uAF3xQwWlJaTttN/MoAFGO4qqR/LPtrU9FE0FBndQeTD0C6tm41XU0skSDmy8loAQbSGgoBuWMpknNYRzXjl8M6GuAMho1W4MFhWGalNayinh9hJvMJBka9Jg7oJzOMRmrMJvHWc9LoH2ODpySTJox6xqci4P9MNo09mgNJtCseUqk0C3BSy6foOwd9BMVq3w7fkAh8jqZpzifIIxFBSZzJK2KaIXT+tJrHRI3h2V9zLgxjmoEJ5KFyzglsrZyvIH1sDXLbgqon03AVOW2wDZ2tXfaaMY5PHiwcdmoD3tgxVcTSwzTeXKqJjL0YmwUXotcJQnDRVNwcwgTDslr5onecv2qqqPzGpAjSTBtJ8ESlGOidU91iHPYWPGxSSzekYzye2eaMuc3i24feWj5ExK36vMVekWIWMxc6ARvBsQdKv5B9kWZe0Pw9O/vno5J+t8YJK1leZPFAn/3xy+s/NatvDNtOBzRYfXAcmqIM4FexocDehROTVl6g9BJj8NqZ92PB/mVbO6AIOA7TWmwmD7ZzHRENY/JI0DCzHAB0gIX3PLToHJtUyLNUWmyRomaT8bsAxWyW39TvHnV8QzhAvJmna/Zi95fY9kjK+BS74drUyp4fWi5bfULksjMorrE8JV02ybpiO7aM1mte5RT6Al2BLvppv59n8PKQVYw/hRwS+d5TWyYKko3pvQUl6+SdtNs1xJWMOPrU0pDvTm1pBM+aLTnP5AcTvWN0dEO4Jo2YPuuSkTVLPl7sBKkrY6sOBhTlu3+/ynPnxv+xThsY86hiJ05IHpy9JHmjFKiPa6m1bU+jerh96OUniFFW4oJlvOAzdVt5s2yPRGzFq9f/iCwr79AtKcmMYQB0lpwZG9Uk03eTTHRwfPD44OT549Pj0+PTR0fcnTw9Ojh4ff3d8fHJ8dHD86PvjR09PHz35/uD46Oh4e5QE+gGHghfKCYd9cHn+4mH0QmVQppVxa3UGFf77iAGK6rJXhkFZbeOh0l6bsbq4xnNxef4CtDrKJwJ5Dkptk9w76l8Sm7LK/vDiI9eUy7dRRdKlp/qkvkXso9yC0d80owM2AbiB1h+ny/MXdsSMuJZiSed/nrRExv9laLqzqORQlVQyfVIpnHWk8+lBAP0czfamDW9UC4hOYawd8GOq1O0CctYQWAIrxvOVgtzK60DfMvvj4wUJ9RS4GeABCNtuUvaJCsbbJNuxcbdHAt+n3t6S7nyUKCBsvH4k6QLk3QvW4sa/90rMeday/ocQiXWuPnwh7baRfPxk/AE3HQonB1sCHdjgxYKxkkTe5vtxEoyKUQ40glS5+MCcKCuoNLBc0KVxEqMzxk+unL76bozeGnLKgGFDuDXX5OFAiS3C/9GdMW48CBsD4/vXtJvG7X2wcfwhG+kNMwx9snGOjn3qhuE7b28cuWNBumHkztsbRy70/DYoaRmLbsh0AAfsVT8vbiDfz78zpi+2GZxMNXjgtwO9a925Yfx1xoMbZ1n34cb5WnfsG6Zovbtx1KEb6g2DD31y0xx0ndt6gs4Vc+PweAe7BYUOXQ435wY2l64bhk7e3DwiXBhujZHuPWPjHMMa9rqZwlTDX908UUsVumE5/Q9uHn97adJ9fePYQwFZa0duv7xx3A9lcRNDGwoq6Y75fwIAAP//koM8ag==" + return "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" } diff --git a/x-pack/functionbeat/docs/fields.asciidoc b/x-pack/functionbeat/docs/fields.asciidoc index 342a28f3ea24..0a528e605958 100644 --- a/x-pack/functionbeat/docs/fields.asciidoc +++ b/x-pack/functionbeat/docs/fields.asciidoc @@ -363,6 +363,34 @@ example: 6.0.0-rc2 -- +[float] +=== as + +An autonomous system (AS) is a collection of connected Internet Protocol (IP) routing prefixes under the control of one or more network operators on behalf of a single administrative entity or domain that presents a common, clearly defined routing policy to the internet. + + +*`as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + [float] === client @@ -381,6 +409,28 @@ type: keyword -- +*`client.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`client.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`client.bytes`*:: + -- @@ -512,6 +562,28 @@ type: keyword -- +*`client.nat.ip`*:: ++ +-- +Translated IP of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`client.nat.port`*:: ++ +-- +Translated port of source based NAT sessions (e.g. internal client to internet). +Typically connections traversing load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`client.packets`*:: + -- @@ -534,6 +606,16 @@ format: string -- +*`client.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`client.user.email`*:: + -- @@ -764,6 +846,28 @@ type: keyword -- +*`destination.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`destination.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`destination.bytes`*:: + -- @@ -895,6 +999,28 @@ type: keyword -- +*`destination.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`destination.nat.port`*:: ++ +-- +Port the source session is translated to by NAT Device. +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`destination.packets`*:: + -- @@ -917,6 +1043,16 @@ format: string -- +*`destination.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`destination.user.email`*:: + -- @@ -985,6 +1121,198 @@ example: albert -- +[float] +=== dns + +Fields describing DNS queries and answers. +DNS events should either represent a single DNS query prior to getting answers (`dns.type:query`) or they should represent a full exchange and contain the query details as well as all of the answers that were provided for this query (`dns.type:answer`). + + +*`dns.answers`*:: ++ +-- +An array containing an object for each answer section returned by the server. +The main keys that should be present in these objects are defined by ECS. Records that have more information may contain more keys than what ECS defines. +Not all DNS data sources give all details about DNS answers. At minimum, answer objects must contain the `data` key. If more information is available, map as much of it to ECS as possible, and add any additional fields to the answer objects as custom fields. + +type: object + +-- + +*`dns.answers.class`*:: ++ +-- +The class of DNS data contained in this resource record. + +type: keyword + +example: IN + +-- + +*`dns.answers.data`*:: ++ +-- +The data describing the resource. +The meaning of this data depends on the type and class of the resource record. + +type: keyword + +example: 10.10.10.10 + +-- + +*`dns.answers.name`*:: ++ +-- +The domain name to which this resource record pertains. +If a chain of CNAME is being resolved, each answer's `name` should be the one that corresponds with the answer's `data`. It should not simply be the original `question.name` repeated. + +type: keyword + +example: www.google.com + +-- + +*`dns.answers.ttl`*:: ++ +-- +The time interval in seconds that this resource record may be cached before it should be discarded. Zero values mean that the data should not be cached. + +type: long + +example: 180 + +-- + +*`dns.answers.type`*:: ++ +-- +The type of data contained in this resource record. + +type: keyword + +example: CNAME + +-- + +*`dns.header_flags`*:: ++ +-- +Array of 2 letter DNS header flags. +Expected values are: AA, TC, RD, RA, AD, CD, DO. + +type: keyword + +example: ['RD', 'RA'] + +-- + +*`dns.id`*:: ++ +-- +The DNS packet identifier assigned by the program that generated the query. The identifier is copied to the response. + +type: keyword + +example: 62111 + +-- + +*`dns.op_code`*:: ++ +-- +The DNS operation code that specifies the kind of query in the message. This value is set by the originator of a query and copied into the response. + +type: keyword + +example: QUERY + +-- + +*`dns.question.class`*:: ++ +-- +The class of of records being queried. + +type: keyword + +example: IN + +-- + +*`dns.question.name`*:: ++ +-- +The name being queried. +If the name field contains non-printable characters (below 32 or above 126), those characters should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n respectively. + +type: keyword + +example: www.google.com + +-- + +*`dns.question.registered_domain`*:: ++ +-- +The highest registered domain, stripped of the subdomain. +For example, the registered domain for "foo.google.com" is "google.com". +This value can be determined precisely with a list like the public suffix list (http://publicsuffix.org). Trying to approximate this by simply taking the last two labels will not work well for TLDs such as "co.uk". + +type: keyword + +example: google.com + +-- + +*`dns.question.type`*:: ++ +-- +The type of record being queried. + +type: keyword + +example: AAAA + +-- + +*`dns.resolved_ip`*:: ++ +-- +Array containing all IPs seen in `answers.data`. +The `answers` array can be difficult to use, because of the variety of data formats it can contain. Extracting all IP addresses seen in there to `dns.resolved_ip` makes it possible to index them as IP addresses, and makes them easier to visualize and query for. + +type: ip + +example: ['10.10.10.10', '10.10.10.11'] + +-- + +*`dns.response_code`*:: ++ +-- +The DNS response code. + +type: keyword + +example: NOERROR + +-- + +*`dns.type`*:: ++ +-- +The type of DNS event captured, query or answer. +If your source of DNS events only gives you DNS queries, you should only create dns events of type `dns.type:query`. +If your source of DNS events gives you answers as well, you should create one event per query (optionally as soon as the query is seen). And a second event containing all query details as well as an array of answers. + +type: keyword + +example: answer + +-- + [float] === ecs @@ -1070,6 +1398,18 @@ example: user-management -- +*`event.code`*:: ++ +-- +Identification code for this event, if one exists. +Some event sources use event codes to identify messages unambiguously, regardless of message language or wording adjustments over time. An example of this is the Windows Event ID. + +type: keyword + +example: 4648 + +-- + *`event.created`*:: + -- @@ -1086,11 +1426,12 @@ type: date + -- Name of the dataset. -The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name. +If an event source publishes more than one type of log or events (e.g. access log, error log), the dataset is used to specify which one the event comes from. +It's recommended but not required to start the dataset name with the module name, followed by a dot, then the dataset name. type: keyword -example: stats +example: apache.access -- @@ -1153,11 +1494,11 @@ example: state + -- Name of the module this data is coming from. -This information is coming from the modules used in Beats or Logstash. +If your monitoring agent supports the concept of modules or plugins to process events of a given source (e.g. Apache logs), `event.module` should contain the name of this module. type: keyword -example: mysql +example: apache -- @@ -1185,6 +1526,18 @@ example: success -- +*`event.provider`*:: ++ +-- +Source of the event. +Event transports such as Syslog or the Windows Event Log typically mention the source of an event. It can be the name of the software that generated the event (e.g. Sysmon, httpd), or of a subsystem of the operating system (kernel, Microsoft-Windows-Security-Auditing). + +type: keyword + +example: kernel + +-- + *`event.risk_score`*:: + -- @@ -1204,6 +1557,18 @@ type: float -- +*`event.sequence`*:: ++ +-- +Sequence number of the event. +The sequence number is a value published by some event sources, to make the exact ordering of events unambiguous, regarless of the timestamp precision. + +type: long + +format: string + +-- + *`event.severity`*:: + -- @@ -1242,60 +1607,133 @@ type: keyword Reserved for future usage. Please avoid using this field for user data. -type: keyword +type: keyword + +-- + +[float] +=== file + +A file is defined as a set of information that has been created on, or has existed on a filesystem. +File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. + + +*`file.accessed`*:: ++ +-- +Last time the file was accessed. +Note that not all filesystems keep track of access time. + +type: date + +-- + +*`file.created`*:: ++ +-- +File creation time. +Note that not all filesystems store the creation time. + +type: date + +-- + +*`file.ctime`*:: ++ +-- +Last time the file attributes or metadata changed. +Note that changes to the file content will update `mtime`. This implies `ctime` will be adjusted at the same time, since `mtime` is an attribute of the file. + +type: date + +-- + +*`file.device`*:: ++ +-- +Device that is the source of the file. + +type: keyword + +example: sda + +-- + +*`file.directory`*:: ++ +-- +Directory where the file is located. + +type: keyword + +example: /home/alice + +-- + +*`file.extension`*:: ++ +-- +File extension. + +type: keyword + +example: png + +-- +*`file.gid`*:: ++ -- +Primary group ID (GID) of the file. -[float] -=== file +type: keyword -A file is defined as a set of information that has been created on, or has existed on a filesystem. -File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric. +example: 1001 +-- -*`file.ctime`*:: +*`file.group`*:: + -- -Last time file metadata changed. +Primary group name of the file. -type: date +type: keyword + +example: alice -- -*`file.device`*:: +*`file.hash.md5`*:: + -- -Device that is the source of the file. +MD5 hash. type: keyword -- -*`file.extension`*:: +*`file.hash.sha1`*:: + -- -File extension. -This should allow easy filtering by file extensions. +SHA1 hash. type: keyword -example: png - -- -*`file.gid`*:: +*`file.hash.sha256`*:: + -- -Primary group ID (GID) of the file. +SHA256 hash. type: keyword -- -*`file.group`*:: +*`file.hash.sha512`*:: + -- -Primary group name of the file. +SHA512 hash. type: keyword @@ -1308,6 +1746,8 @@ Inode representing the file in the filesystem. type: keyword +example: 256383 + -- *`file.mode`*:: @@ -1317,19 +1757,30 @@ Mode of the file in octal representation. type: keyword -example: 416 +example: 0640 -- *`file.mtime`*:: + -- -Last time file content was modified. +Last time the file content was modified. type: date -- +*`file.name`*:: ++ +-- +Name of the file including the extension, without the directory. + +type: keyword + +example: example.png + +-- + *`file.owner`*:: + -- @@ -1337,24 +1788,31 @@ File owner's username. type: keyword +example: alice + -- *`file.path`*:: + -- -Path to the file. +Full path to the file. type: keyword +example: /home/alice/example.png + -- *`file.size`*:: + -- -File size in bytes (field is only added when `type` is `file`). +File size in bytes. +Only relevant when `file.type` is "file". type: long +example: 16384 + -- *`file.target_path`*:: @@ -1373,6 +1831,8 @@ File type (file, dir, or symlink). type: keyword +example: file + -- *`file.uid`*:: @@ -1382,6 +1842,8 @@ The user ID (UID) or security identifier (SID) of the file owner. type: keyword +example: 1001 + -- [float] @@ -1505,6 +1967,49 @@ type: keyword -- +[float] +=== hash + +The hash fields represent different hash algorithms and their values. +Field names for common hashes (e.g. MD5, SHA1) are predefined. Add fields for other hashes by lowercasing the hash algorithm name and using underscore separators as appropriate (snake case, e.g. sha3_512). + + +*`hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + [float] === host @@ -1738,6 +2243,27 @@ type: keyword -- +*`host.uptime`*:: ++ +-- +Seconds the host has been up. + +type: long + +example: 1325 + +-- + +*`host.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`host.user.email`*:: + -- @@ -1951,6 +2477,17 @@ example: err -- +*`log.logger`*:: ++ +-- +The name of the logger inside an application. This is usually the name of the class which initialized the logger, or can be a custom name. + +type: keyword + +example: org.elasticsearch.bootstrap.Bootstrap + +-- + *`log.original`*:: + -- @@ -2466,6 +3003,42 @@ example: /usr/bin/ssh -- +*`process.hash.md5`*:: ++ +-- +MD5 hash. + +type: keyword + +-- + +*`process.hash.sha1`*:: ++ +-- +SHA1 hash. + +type: keyword + +-- + +*`process.hash.sha256`*:: ++ +-- +SHA256 hash. + +type: keyword + +-- + +*`process.hash.sha512`*:: ++ +-- +SHA512 hash. + +type: keyword + +-- + *`process.name`*:: + -- @@ -2478,6 +3051,17 @@ example: ssh -- +*`process.pgid`*:: ++ +-- +Identifier of the group of processes the process belongs to. + +type: long + +format: string + +-- + *`process.pid`*:: + -- @@ -2528,6 +3112,17 @@ format: string -- +*`process.thread.name`*:: ++ +-- +Thread name. + +type: keyword + +example: thread-0 + +-- + *`process.title`*:: + -- @@ -2538,6 +3133,17 @@ type: keyword -- +*`process.uptime`*:: ++ +-- +Seconds the process has been up. + +type: long + +example: 1325 + +-- + *`process.working_directory`*:: + -- @@ -2584,6 +3190,28 @@ type: keyword -- +*`server.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`server.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`server.bytes`*:: + -- @@ -2715,6 +3343,28 @@ type: keyword -- +*`server.nat.ip`*:: ++ +-- +Translated ip of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: ip + +-- + +*`server.nat.port`*:: ++ +-- +Translated port of destination based NAT sessions (e.g. internet to private DMZ) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`server.packets`*:: + -- @@ -2737,6 +3387,16 @@ format: string -- +*`server.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`server.user.email`*:: + -- @@ -2827,9 +3487,9 @@ example: 8a4f500f *`service.id`*:: + -- -Unique identifier of the running service. -This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service. -Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance. +Unique identifier of the running service. If the service is comprised of many nodes, the `service.id` should be the same for all nodes. +This id should uniquely identify the service. This makes it possible to correlate logs and metrics for one specific service, no matter which particular node emitted the event. +Note that if you need to see the events from one specific host of the service, you should filter on that `host.name` or `host.id` instead. type: keyword @@ -2902,6 +3562,28 @@ type: keyword -- +*`source.as.number`*:: ++ +-- +Unique number allocated to the autonomous system. The autonomous system number (ASN) uniquely identifies each network on the Internet. + +type: long + +example: 15169 + +-- + +*`source.as.organization.name`*:: ++ +-- +Organization name. + +type: keyword + +example: Google LLC + +-- + *`source.bytes`*:: + -- @@ -3033,6 +3715,28 @@ type: keyword -- +*`source.nat.ip`*:: ++ +-- +Translated ip of source based NAT sessions (e.g. internal client to internet) +Typically connections traversing load balancers, firewalls, or routers. + +type: ip + +-- + +*`source.nat.port`*:: ++ +-- +Translated port of source based NAT sessions. (e.g. internal client to internet) +Typically used with load balancers, firewalls, or routers. + +type: long + +format: string + +-- + *`source.packets`*:: + -- @@ -3055,6 +3759,16 @@ format: string -- +*`source.user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`source.user.email`*:: + -- @@ -3123,6 +3837,36 @@ example: albert -- +[float] +=== tracing + +Distributed tracing makes it possible to analyze performance throughout a microservice architecture all in one view. This is accomplished by tracing all of the requests - from the initial web request in the front-end service - to queries made through multiple back-end services. + + +*`tracing.trace.id`*:: ++ +-- +Unique identifier of the trace. +A trace groups multiple events like transactions that belong together. For example, a user request handled by multiple inter-connected services. + +type: keyword + +example: 4bf92f3577b34da6a3ce929d0e0e4736 + +-- + +*`tracing.transaction.id`*:: ++ +-- +Unique identifier of the transaction. +A transaction is the highest level of work measured within a service, such as a request to a server. + +type: keyword + +example: 00f067aa0ba902b7 + +-- + [float] === url @@ -3244,6 +3988,16 @@ The user fields describe information about the user that is relevant to the even Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them. +*`user.domain`*:: ++ +-- +Name of the directory the user is a member of. +For example, an LDAP or Active Directory domain name. + +type: keyword + +-- + *`user.email`*:: + -- diff --git a/x-pack/functionbeat/include/fields.go b/x-pack/functionbeat/include/fields.go index e0271504e1fb..6dc69a7c23b8 100644 --- a/x-pack/functionbeat/include/fields.go +++ b/x-pack/functionbeat/include/fields.go @@ -19,5 +19,5 @@ func init() { // AssetFieldsYml returns asset data. // This is the base64 encoded gzipped contents of fields.yml. func AssetFieldsYml() string { - return "eJzsvXlzHDlyKP7/fAr8OBE/Sutm8xB1DB1rP66kmeFbSUOLlMdrr4ONrkJ3Y1gF1AAotnpevO/+ApkJFOpoHhJbK4VpR+yI1VVAIpHITOT5Pfv1+P27k3c//X/slWZKOyZy6ZhbSMtmshAsl0ZkrliNmHRsyS2bCyUMdyJn0xVzC8FevzxjldG/icyNvvueTbkVOdMKnl8JY6VWbH+8N94ff/c9Oy0Et4JdSSsdWzhX2aPd3bl0i3o6znS5Kwpuncx2RWaZ08zW87mwjmULruYCHvlhZ1IUuR1/990OuxSrIyYy+x1jTrpCHPkXvmMsFzYzsnJSK3jEfqRvGH199B1jO0zxUhyx7f/lZCms42W1/R1jjBXiShRHLNNGwN9G/F5LI/Ij5kyNj9yqEkcs5w7/bM23/Yo7sevHZMuFUIAmcSWUY9rIuVQefePv4DvGzj2upYWX8vid+OgMzzyaZ0aXzQgjP7HMeFGsmBGVEVYoJ9UcJqIRm+kGN8zq2mQizn8ySz7A39iCW6Z0gLZgET0jJI0rXtQCgI7AVLqqCz8NDUuTzaSxDr7vgGVEJuRVA1UlK1FI1cD1nnCO+8Vm2jBeFDiCHeM+iY+8rPymbx/s7T/b2Xu6c/DkfO/F0d7ToyeH4xdPn/zndrLNBZ+Kwg5uMO6mnnoqhgf4zwt8filWS23ygY1+WVunS//CLuKk4tLYuIaXXLGpYLU/Ek4znuesFI4zqWbalNwP4p/TmtjZQtdFDscw08pxqZgS1m8dggPk6//vuChwDyzjRjDrtEcUtwHSCMDrgKBJrrNLYSaMq5xNLl/YCaGjg0n6jldVITOOq5xpvTPlhn4S6urIH/i8zvzPCX5LYS2fi2sQ7MRHN4DFH7VhhZ4THoAcaCzafMIG/uTfpJ9HTFdOlvKPSHaeTK6kWPojIRXj8LZ/IExEip/OOlNnrvZoK/TcsqV0C107xlVD9S0YRky7hTDEPViGO5tplXEnVEL4TnsgSsbZoi652jGC53xaCGbrsuRmxXRy4NJTWNaFk1UR126Z+CitP/ELsWomLKdSiZxJ5TTTKr7dPRE/i6LQ7FdtijzZIsfn1x2AlNDlXGkjLvhUX4kjtr93cNjfuTfSOr8e+s5GSnd8zgTPFmGV7cP6X1sN/WyN2JZQVwdb/50eVT4XCimFuPpxfDA3uq6O2MEAHZ0vBH4Zd4lOEfFWzvjUbzJywZlb+sPj+afz8m0WaF+tPM65P4RF4Y/diOXC4T+0YXpqhbny24Pkqj2ZLbTfKW2Y45fCslJwWxtR+hdo2Pha93BaJlVW1LlgfxHcswFYq2UlXzFeWM1MrfzXNK+xYxBosNDxn2ipNKRdeB45FQ07Bsr28HNZ2EB7iCRTK+XPiUYEediS9YXzvlwIkzLvBa8q4SnQLxZOalwqMHaPAEXUONPaKe38nofFHrETnC7zioCe4aLh3PqDOGrgG3tSYKSITAV34+T8Hp++BZWEBGd7QbTjvKp2/VJkJsasoY2U+eZaBNQB1wU9g8kZUou0zItX5hZG1/MF+70WtR/frqwTpWWFvBTsr3x2yUfsvcgl0kdldCaslWoeNoVet3W28Ez6jZ5bx+2C4TrYGaCbUIYHEYgcURi1leZ0iGohSmF4cSED16HzLD46ofKGF/VO9dpz3T1Lr8McTOb+iMykMEg+0hIiH8kZcCBgU/ZxpOug03hJZkrQDoICxzOjrRf+1nHjz9O0dmyC2y3zCeyH3wlCRsI0XvDD2dO9vVkLEd3lR3b2WUv/oOTvXr25+7qjuPUkioQN3y1Brk8FAzKW+drl5a3l+f/dxAJJa4HzlXKE3g5axvEtZIcogubySoDawhV9hm/TzwtRVLO68IfIH2paYRzYLTX7kQ40k8o6rjJSYzr8yPqJgSl5IiFxyhpxKipuOKkgtHzLlBA53j+WC5kt+lPFk53p0k/m1etk3Sczr/gGzgNLRZYUHumZE4oVYuaYKCu36m/lTOvWLvqN2sQunq+qa7YvcDs/AbOOryzjxdL/J+LWq4J2EUgTt5W0cfzWS/NxgxoVeXbEavMukjhNMRXNKyDC5Ky18c2OdQmgtfklzxb+StBHcTpOwDNdNjeA6n+na2wb2R2Yno33xns7JjtI1JiskB095mXz5BpF5pi+9ASXixkofBx3TirpJHcamBJnSrilNpde01ECFCp/6gJsqKAYMecmB8Hl5ZJWdpS8j0JrKvGmL7XXfGeFXvobmtfpWmrz+ctTGhVPRQNmDzb/wL+eQAZcxAoV1RX/ztnf3rGKZ5fCPbKPxzALatqV0U5nuuhNhTdaL1ZakwY9y8B1XfhLUdAEApac4cpyAGbMznQpomyuLeo4TpiSbYVrujZbjVZvxEyYFiiqs0CLagb9TDoo7uxURB0MdNAEAQgC82CpedjmZooUftSmiYjCBP7k1Lb2CKFRG+VPKg/eb7XCDQBdELW7YEQZGKzBr9KuN6Rn6rhfO3DGwu013nlxvN0wT7RSAK9GMeEvwlaUXDmZgZIuPjqSKOIj6gojZODfRc4e5IrT7Er65co/RKPY+4UKA8q+la7mtB0nM7bStYlzzHhRBOKTKog1J+barEb+1cAQrZNFwYTyqi3RLZpGPNPMhXWePDxKPcJmsiiizsWryujKSO5EsbqDUsfz3AhrN6XPAbWjBk+0RRMS741sppzKea1rW6yQmuGbyLCXHi1WlwJMQqzwF0Cu2MnpiHGW69JvgDaMs1rJj8xqTydjxv7WYJZEBNgsGq1gIZjhywBToPvJmB5MEGVtCaf8BaARYHmNNgu8gU7Gspp4UCZjBGvib3GVUDmpGKgfaNUAAdcJ2rGwK9OVE/YGkVLoqOrjzaL9WWsf/uJ/wFtFNOzRfvhrs2cHeBvoipf9F4ctwHBRGxB2dH5x/HFrzrnQ40y61cWGFNOX0q1gqt7q32rljOBFHxytnFRCuU3B9C5RkuNkPfjeaeMW7LgURmZ8AMhaObO6kFZfZDrfCOpwCnZy9gvzU/QgfHm8FqxN7SaBNLihL7nieR9Thc5SlX4dOHOhLyotI19qG6W0mktX58irC+7gjx4E2/+HbRVabR2xnedPxs/2D1882RuxrYK7rSN2+HT8dO/pD/sv2P/d7gHZx9f9sekPVpidwIuTn1DbC+gZMdK9UQLrGZsbruqCG+lWKVNdscwzd1A5Eub5MvDMeLNBCpcGpWkmlBOGFK9ZobVhqi6nwoxAk1/IRq2xcVAEr2DVYmWl/0ewrGXhWNsEhHfaJd4DsBtKxXjtdAksfC50WG1f/59q67TaybPe3hgxl1pt8qS9hxmuO2g7//ZyHVwbOmoE0+BJ+7daTEUbUbK6AYb4Qps4T06jgA4cEYRFSlloBNBKeNkbTdonp1eH/sHJ6dWzRvHoyNqSZxvAzdvjl+ugTidHlfYOor41ySl+/UmC/aANhzbu7vqGdUaugUwbd926ayvMWJRcFhtiaZ6jMZggbMMAALO6KAYOx70CsW2ZnwamBT7Gr7gs+LTon5njYiqMY6+lsk6QltWCF1T58casr30L5Iys7TBxNJLAzXG3KrjzhDCAV4Rzg4hN1SOcrA/EgtvFxuQlYsrPw/w8/rBl2hjhL6stU/8MryX+RS9olFar1HGIZynhZB+sIDPmBFYhc7xOwB9+dZPoXsq0muFe8aI1p1dAMq6aazQL7uAO66MZNsD+fulw4rpLWpErAgx9qDYkss4WnjGh7gGuH6n6gCRHksORbNnWdI1TRtNaeLDesoZRIAzJIw+cGYZiYC6aGR5dw43TC6/IaDEOnBfsxmytk2vG3gpnZIbGZ5sat7lir18eoGnbU8hMuGwhLKheyehMOkt+xQZIT11td3jLryltNJq2QaBxTa3IYWlEqV00sTJdOytzkczUhQxh4ow8amFBYdNV8ympjW3PPQ7aDASuQ5o8SEc/rLQNqISwuxhRMrjUbI4zb583CMK5wGVq5lzJP/DQyzy6wemUrVguZzNhUkMKKMcSnL+M4/HccUJx5ZhQV9JoVbY1q4a2jn89i5PLfMR+0npeCKR/9sv7n9hJjo5qMKP2DnxfnX727Nnz589fvHjxww8/tNGJElIW/tL/R2MruW+sHifzMD+PxwoaaICm4ag0h6jHHGq7I7h1O/sdPZe8C5sjh5PgVTp5FbgXwBoOYRdQubN/8OTw6bPnL37Y49MsF7O9YYg3KLIjzKn/rw91opXDw74b694gehv4QOLRuhaN7mBcilzWZVt1NvpK5jFwYZOqDnKAMOE4HM40KIsv7YjxP2ojRmyeVaN4kLVhuZxLxwudCa76km5pW8vCq+OGFkU3x088bqk4RkZP2A8iufXwGodXfLHt1CB3Qy9mLgnjqUQmZzJcHCMUaLMnvxSZ7vUsHSQJwBRWhHkXoqgSBRLkFYa0xqEtSUK18ghyshR3EFAb0fFICW4WL/P2GZYln2+Up6RnAyaL9lIEaMktm9aycF6cD4Dm+HxDkDWURXDxeRuAJCr0+tmT6NBr4kO7zBYmpVDL1rwb3I1mzY1FKHITJNlNsRMcnZVc8bnX3oCfRDrocRKMSk3YSOJaSxnJq87ja1hJ8ur1LljUnpO3wcSKdqDddnTmwJiJ1/UmfytyH/K3fo0OwZY/81ZewUaNxYDue/IKxmHBO/g/2yuYbkqwIFLkfucQfTHXYHoMHvyDD/7B+wHpwT94e5w9+Acf/IPfkn8wEWLfmpOwBTrbsKfwDsL+y7kL12LgwWf44DN88BmyB5/ht+YzxETxTqr4ddaEt8LxnXR3gr2RUtFxytvc5m/KThhIMf+8/K0k/R4UMor91bAYy5wes4nI7JhemmC2TwCjoXBw43miLGvrMOcJDkPRi/xm7Fd//f69FmYFoeyY7BXJSKpcZsKynR26Zpd8FQCCbP9CzheuGPKWJauB76lAgQet8NJUKifmhiLMef6bBzXI0WwhSt7BP2tl4dq+Brk/3hvvpZRjjG6Ztl/HB9cnpDam5QyylygYHgeEc8TVil1K1ZgxPmAuQon5U/gemLMx9dIjrxDom/VoDmmowKMyboVtcjbDsmDvpbOimDUuWa5w9DvYpDakMwMyYfBwb0DboSAA29rpBk3oA9JzAII00X09GDHZfXCxIW07pbGrTrLQ66tbJj3j/g65TkLiw7D3pNBBCUQvi5FZi1YiSR5DHn07G8mTT+ApnqD8liV5xmAOXOA+8iZtODDpN02+PzCWkAMNSTiyFP4GG1xS/qkfKI7RpE7rWbIIGi8MxUMqLoNs0xB9QTEVTe4UKvRsKjBFivRyGpMH+63TjKcq8QgtmgMJWFPhlkL4mUKmhcopcCI6J3Eyyl3CZOqs0F7Is+OwEzejG29QNGSpjfDXcLAxFTAiZrbAn2lGOgA0jOjkNRq2yeluYT2llgblpSi1WTHP5CBzhobLE8Q3BHdVF0oYdPvLJmmeXrZeCRI5pszfJQLkFvahT478wNFZxiusHUHpkm1vAWXPRgsIpak1B1AmJWHG7AT8lLB7jXax4IpN8IWQnzRpUjHjRvizPgGE7PA8n4zYhEh+B0hewKOZLMROZoQntAkm9YQCLnHEmKkdKI5WJv08JZh7+kLSK107FbfWI3MH87ba4oJA38R2vMbDQDN0kR+F3ELOF5SoNswDgUOCAJ31diWOCbsDeXGdzUGCmIzCnlqhLCWMNdYrHsGMcDUjB+2IhxTCX7nxhxsKJcxqCESLqo+eeVVoxJaCVQUHWwEFITAehyyoKgfPMlE5SJamuASUaUF1GrEKyzHVVqCrKuP1sEENdhqceg1riJuMlHXDHsdKSd19JCLHQXqhbcNllDxPgspCcc1GcKDZkJOOSa0rzP7r1RYiIkEF0h9V6dl6RgaZphpUzBFMHjXbSrDGMSNHHSjeFIvKdFnFiWKlti7JWgSrqieipW4KL1n0sU3FgJaMRzr8mTWuq6xdfijjRQZ+SrLuFHwVZRXgiSQdVYwCFZ6EThO90hIdsC3waSi7YqwLUlfkTHZqAwRISq1kk7HLkiG2t0GTDTvm/wxxYU6zSyEqVldIrPBRWraqjVXIVQdI23j0LBPVvIwXo3RnG6fhwG07545bcZOt7ZM4WWoPoWk6qfyZVv4oo5F/Qu9M2CPP2a1wbJfEsRXusafnYC7HEhReeWC2njbgw/Wn1HldCAusrnXsUj6JmoHfwdp4WitWodqUVM2k6YUfSaT5Cafxm0rQwst9FmMdd+3Ap7w2t3H2DNg3O19KVdXuIvyouNJWZLpJQ9e1S1/g9q0sCjn4TmVEJi3s2/7gZr6iqVvixCMrmbZdbwI5AshrQB3+LbzOaAS7VHqp0qprDZW64VMfjjTMrvDujqMnsUrxzqFuY49cx7wbUHt8u8uyYVBPBfG5F3hXqT/Kc/WCe9mFFYg6QUwbNAn+zO2CPaqEWfDKQh0iqM8zk2ouTGWkco/9fhq+JJnhtN8AEK1OxwXkotTKOuOXD/clsEpItxqw4oco0KF/Hf/l5asvduU9eeVXE0NkEnW2A/NgiZpLeSsC+mSF248/XDGNZPhcXkEQdVe1W5IK1g37S0gy0Gwj3EIVOLoKJra+azTFjjYOTyfNmBPP2ITXw3nBTTn5OhU8ALJt5AC+vWl5R9IBXcbXVubBikTpLar1ZjJaV/5pE0tu9Rderuzv7bCRoKptYunv+RLsQrG2oJ6BG9xEavpAKtI1vGSNEqu0lzO5+CiQ5+c6u0jikXNpPaXkKO/BwQDqpOAmW4i8Idhp7ZiM1Z6MF+TiKuiykwvUtSZ9TJ6Jiu3/wPZeHB08O9rfwyjil69/PNr7/7/fPzj85zOR1X4B+BdzC6/y453C4LP9Mb26v0f/aE6mNiWzdeYVy1ldoBpSVSIPH+B/rcn+vL839v+/z3Lr/nww3h8fjA9s5f68f/Ck7TvVtcv05kI1PPuiKdZxsFbt1cZe4C8xGdqYmsNs2zK2NXJSUSlUt2lsNfgicSdCIdUBnXFZ1EYM8qQ44q140+15Uhz39rwJYW7tnZH28sImh3LdMZ0Vmg+aYd9Le8lgBCzaJ7Unzrba9kiM52NmiXCZ1QWAaB83ppgPVtDlCRyrcH2hqx7qawthuiG4EfYLpU15C/pbu4jtd2C3kX+IHIa9YUGjaFrzGvksLmLP7+X+3t5AAbiSS4UBOOTZXOka9qzECE2uwApJRYzgssytlXNlE4Bs+/7oh1hyzIy2wlOPapaBWCPfES+KUKKpo7hacSWSaKZ7CX44ozE7pru4oWHOjgLw6wKjrRo9MNzMmy/oLJSCK+CsV8IkN/ios3vEggvHc+ntxkpUV0EJSQxycJPml4KBqZWmkiIkKyorrQPzM+IyeOs6p2v7eQex/qrw2XcCvHDceCsgK2V6L2hxMn8/aKw9ay4G/lqzweS07UTMNpevpMBqa0nb27axNqT1RRkJaHJzEMxtzbUwgucrYju5mPG6cOxsZb0C0JgwEu5zggYTgJQXmPG3lDY1hRw3DDlOilMCoRyBdVJpBV6Ck1c0+dbr2uhK7B6X1gmT83LrcXKGp1MjrtBxEV4/O996DB4RxX7++agsG+KWvAhv7ew9Pdrb23rcOcubqpD4XiC5gAgiTbtGr1tcC1Wk51ca8jZjzkJTdRzCP7xuOk4rFM8kKcfkq/sx/H1tWT+oqd/x6zArXP+SAi4zy6aeK7QtrOR68r+CNz44TMC8AryyKdnnp6Pa4UGh49bqTDalgUFNCzX9WoXm7Mhz612y3AS+gQ4f2FCvnmgrqBo4Og1gypOgrLK3aOnzaP2vH0/e/neoHG4bvxVl/kLxP3Bso7YTVIt+zgafzQRaV/3rnfUEqklK7pMx6i5u7lumyKzjgW94KHoPIJbCcYybBRdJh33lwi9/Q8zrFQy+JhsO07SLjnoCc/djVe6Pn8Iux1m6OkdMCCn0kgluVx5EJ4CEpitEaPx4IHKjItkeo2s3FnF3aiQUdMf4Os86fzp59Xg9Yhua2zQsaWZvHw6pelEc95hcrHPR7kwRgAguspRPsbbBYWMJxh6oBB8eFJ05XnSqU/aUo8P9Z20Y75cxkEUJNJxS53Imu8xBL9XGEppROvgJtsFkYvrZghV3m7K5nnK3CEptn0at/OM2eF4XZQ1L82P4nYa0K/YoGkq0v9DwPA+628SPBfFv4CqfPO6ol9zMhbvYICrOYQZANmgcdlUWUl12gp43mIAP6AJjKbiURiyXBpQMgqSDkXpjLPWcQjmBm34Abmqa+3cSnfXorMNqkZDTcKq50KmC9hP9eY1+9pPQabBexo2/pDX1VXhjEg65J2kpGa5SHand4CdJV2kpeqSU5cLIaGNzIluAbb5pGeAhOzlNYmfQSWl2bF1VhYzeylspN19Pht5Xn533FWbmfWVZeV99Rt5DNt7XmY33NWbifQVZeP3LQpBf8cF6CXYes32SWOBSkKm1CT6HdyioHBoviEJc8Xg4SStL3MCfUtrkq8ps+tLpTDFoQdtWSPfP4e9rzUShAE/LTERl+Vmmy6p2GD5M1aJiR6mXZxgvG9pCDRss045QjVkF+z81hYDayQMh9hrUQlBTBoOG03Bhv1bAa4wPphEX3ORLbsSIXUnjal6EQk92xF5BRZCk2g4Yodhf66kwSjhoD5SLO9XRMNlCOpElTq17TZaqQrBcaOSQzNc75x9fPLt41i7X8FA14aFqwt1BeqiacHucPehpD1UTNl81wcvPDUGy/TONnVZHTONIXNJqL/hcl+SWZpMA2cTrDqU/v0a42mAp2F6xxe1rtbp7bbGHek5awOnYRjyGmCZqGINJyCNwkZM3PeqvXsWVag4RChSQfm0RVdSUKaQZXYIesxNozweY6mLh0ypigAYkq+EiBpupZPEzbeXwnJuiz3fX0iYY0yjvHagyociEEj9AcTCM9iAmCZFev9e8ANN4HJNKimFVBkzD8wCQda7JXoKscNhr6yWJYbnIZA4Jsl53BTJqGLv273c2XtvxjJeyWG1INP1yxnB89ijY+ozIF9yNWC6mkqsRmxkhpjYfsaVUuV427v+mih682YO7LjZVn6On81J9DNDyg88nZJ+HzN5hFZRnHgdv9W/8SnRXcOlV/i+2Bpwtgg13LsOXFC/Udw2ND8d7O/v7BzuUF9aFfoMKzRr8h/DlBPvrEP4fXWjDtflLQRzmI7r3upG2I1ZPa+Xq62idm6Xs0fpgdYXNAX9bGtnfG+8fjvdb0G4q2CW0A+2w3x+1ocrgoVox9aQlz0OrDrsfApoaT2KF5QkUkr8qR4kCDJHXia4bL+ujtOVrUoM89Xg0sjqOOCSzB2qdPFQcalPXQ8Whh4pDDxWHvu6KQwvnWlb8n8/PT+Hvu/Qo8R/FcNhxqA/DJrUpJiEwVWA0ddJVE4A0RYCXmuLe3p4fPpjqfDUeqHh7U0DGjVVvz1rxGW0wGczaRe+LF8/Xg0jBNBs6w+d0HcHNuBbKn0VRaLbUpsiHod0ALs+140Un4qWD0UceWDjsC8G9HtBXrvYPnwwjuBRuoTeW6NdCKU7VSYBGIsfUACgXMxVpzoDTrNBLYSDn27PQUINqzM4EJcrqrC5DnFcc21LJlq2TEFbvtbzXL8+2+uaxuXAjVkHtmKp2g2iCFtFmYwFb72n4JqUmxVxvNz3vsUe7u9NCz8f0dJzpcrcDu620suKLn3Oc9rYHPQXyy5706+Bcf9QDvF/6rBO0n3bYCWjruKvtgKn3tqCvT7Fp4xQnGrb4Hu613WSbveIBXOvuzPvjtNNJqDdFEv0N/XmjQEebE2+V+dGQ25lm5txGMsPiN3GH/CVkOnmooheEKoX1shexg0Ar+XnJjZqM2ASKpvl/yIFEUWFMazmbTLgNaWytPC6/mJCAy7vFC+DoJ28kOvEMazQV0qH73bEaSsREtbXiplUP8QTtnoY35QgnNGxQ3JAqUgspNMEPBWT8iGmmXtgLGiVNEO3kh9JiR70FhQTgOOaCX4mYe2T9pmIschbqKWKIIVoGhMo0NkswTIklK6QSFrrJXSW3FH+/KQRXkLjWBvlz85eZ1ZSevL0NeoCX9alxeBosYKAtfHYaM7jfwFHxdkVnP1rTMVsm5Qbvkkc3FO0LuTbtOA+0p5RlrQj/GBasr4QJHKQJKmG4C0nODsVp2LS7UXjjk6JCwuidah3dLKJQKOgucRkVdubYYKbJMV7d5vJKKIzQTWclDlcZ7XSmi3apIm6m0hluGtM/o8RWyieDkoQWD0UpM6NDHtMIKJAXVsNkKzz5zcv2clWJxpwms99HbMYzMdX6csTcUjqHXgtp2TKtSORZTVMmqinyya6EypNqShAyjd0UY3ixF7F5DCeOBRPwFOzmXvE+OcUYajuCquJ2xJIxl9KEtMGvUDXnst0J7r77s2yjyoWqljNcWVDEYUem2p8baQTVb2tl90+oMhV8SUn3aVn18DwU+hmxSTis9BPKLtnshK3LPgKePHvRQgBxELe62FwnzGM0ZUGpT8goA6adFLI/OcVKk0RN3LKlKApicnE94fg10Qpt/jeOqeicOa2LHT5X2jqZee1R5dy0Om3GYWeFXqab8UZwozBpnbt4NZpLt6incCnyBAKl1XYj8nZkvuN1tYHywEeLX/7Jvjv8+Z/e/vT07d92XyxOzH+c/p4d/ue//bH359ZWRNLYgHqz9SoMHvS0wK6d4bOZzMZ/V++FXw+WX2rE6dHfFft7RM7f2Z+YVFNdq/zvirE/MV275C+pnDCKF/iXp6Dmr1oB4f5d/V39uhAqHbPkVZUUKKb+sV547WBLvbJJDqU6taMokBLFJh0zci4/zLZlEK/kF38lxXKMMKyZOKBGG1YJI0vhhEFAWkDfDqYGkBYE/r/gyqDJ0pHjpOOtLjkR7lt0M9NmyU0u8ovPCT5IWnLEPHU6rslPpCBXRn8cqFX1w8F4f7w/bhdPkVzxCwxf2hCDOTl+d8xOA3d4B1OxR+HkLpfLsYdhrM18FwUz1LbdDfxkB4HrPxh/XLiySJLoz4iPgLwKdUzCV5b4Dy+gpgVwMNB43gn3Y6GXWF4N/kUW2zhuoefh1leTyXZoTT2Et1MON+0WQeVoumIavJxQbFwH6WubELYgl7rQ/gRWu1/lTLbA/rwuKSRwaZBPErn07YDQbX4ZELvhx0Y/IwE8LHgP2kaKQDWbuMq+eR5uF43MhJgKJj6OQaKNWAEU9RvPvCbpkeZlb6Phfn2aW/SPRPd4gHoTKDzzBM9tpOWEiaHWDq5U3hSCEOyvOE96DGPzgAbDBV955lTn1Yi5rBoxWV0925FZWY2YcNn48deHeZd1EL+huIQTFDq/nJ1AGnaBQnSZxg8Esn7jsTj2uDtEDCa3pMqKbMQqWQJCvz50eqAT0wBVqmm1jPglfXZd/oeKn/drhVQik7wIFDyKybEYB9e7UmNxiVh4NxdOZG4UxoePsLrIzSPutOUbKVdJsdd2xmuMEOEsq63TZUz7wEGhBTl4u2mpnZonWs3kvG5akTjNTK1ujwBm9cz56ZJaaO00lJk0YsmLwo68hmtqCOlBDEmtdisDS4ShQlBi0CETLdEKZbWJFa6WYtqCIpkEgsALbS0bGtoj8vj0LWHDpm1WAzWkBhyO1aDX2G+IQeHgGEaiVqO0Uhyu00ZSsKHWC5KDbRTma1AcKqzQmFRnhb0l2+rvtahxYPb6/A0kLmkFVBPuelQqut3GhMgpWJqMANMgFLTKBfQHIHxAR9jXL8/uYHR6SLZ5SLa5O0gPyTa3x9lDss1Dss03nWzTzbWJ0rdt//g0o0y/Rerw8F+szWlLUX3IenjIenjIenjIerj/rAcrjOTFZg3G4X5Nk5G8v6mI1v01BwvdBlK2Gpu6XFfYXhhKdvQXw6A5BUN0M9KqEnY8FHUTXAUmbTsQLp4QhZNb+E9lqUXYxxX8QxeFgDAdvMT6fzVX0IHYiDBmC6Ut7/N9IjWuHGdIY9bHHQiu7616DySVMJYmbGnOlfyjUfaDmaf7/IY4kHSccL8XyshsgYQDF/t1vcvKiqsgpbUhfbVFdJ1IjTQwpOlNuhBFBWW5uTFczUO7HkeVb5OeP1xhkA54DNpR+xGMZj13qdPxD8hTSUH9YvViUvqI6kHD1VukFFnwGbDgG8jpHOysnXYBa0hHd7j77aMPv0nN8BtXC79hnfAbUgi/YW3wq1cFEw9pbOZBXO40eXTrZtprmVvs+jss6TKuGmnX5OCRzbnd+w4CG2MTYZnvJrRMQSWtuFpgwKED67iCXLyZE4pZx1c21D8O3X2xGzeP/bNAQawkOmogU7HQU14klegDuI1B6Xb1r+a3yUD4tBgwY/iKwiUASdzMwZGW2sneQp9J0idweZXRTmQOnCfSyatWEmRP76Q/d5iNKZo7bKeI/6xtvFPssND+px1FIT6KrIYuCBtCxfEUusMIDNelHQxYaWbvnZDd2prdqVS7YW1fom4lnTiSQnGj/NUC2kywjBeFgJTxueFlTIC0spQFH+gE3AW+ujFL9E5ZI6fxCPaFz8FhOzCp6s39+VkrpxwKxdB2bvvlDQHSufJ+ZiOV89BlNaUkapjSdwUc7O0/29l7unPw5HzvxdHe06Mnh+MXT5/8Z6fTxsIInt8uJfxOGDqHgdnJq5s3CLj+pikbJunEu3gcwvMRZjkgqYOflOJCqvRcsJdcYRj3tOmz6Y7ikEmpA8bZ1OilBdtDSA4hIAIvWIopq/hcJJ1UNXazb2/RUptLqeYXGN/Ua559r2luNBeLcwXzRRShXW610KXY5QU2rGgSx5rAAJLp75NH18r0prWOwD7ooVrpjGeykM4L50peaWxHbHQNvfQrKbKkgxV0ZwmbDQYSeMF226pQOLwVApqwl1ytvBKWQWiAv9q+fnkWujqdpyDQ0NgsD2w4eIMsR3g1hsyCIAuhaZWfIpSp0uSYAvltK63y5hRR+otiE8LieBJXcgyNf41w0eDjMdS4EIQdJflDU8FqKHIEbfaj9WRE8Z6jhghCJNyIZYWEtmDhVa7yGByVBqBCERCwD1QV9JQtCnZyGtQKpxvoZTUZoW7FQd1RhDSqbIDRhienzBl5JXlRrEZMaVZy5yDBRUQxIR1Mxo3IR2y6ikE76VRHfDwdZ+N8chczw21acAw7b46LmA93cmpxj7VKGlGnN/l+/M/Z7aJ/6L2BvCAiHqoNEYNRMq0URSrNoiGOwimMmHOTY5yKtdhevHnfYpt0GWMpvbqJoayZNkmj4h+1YecvT2NfIGCaEUyELRPS/00IkkpCoYmzv72jMM5HNhTsD3r5y9MEljFMgvViYvBtdyaqgVusevgI29eOgVc29EMErkDBNoxnrg5OW4zkE6ZkW3G8LSyXPItqZQqF6gBuQ4Ux+JmuGcG33M+oCqyEisVmyNhsZ4p0HcSQzloTcOhlBaugEZtQICz28VutsuYegyedvh4arEFtUwikGdKfXtzGHXTYh5xVevMlDr8bltDuq4LXLp57Ll9y5WQWguspK0t8xNZIxM+aG5G/qs3qwr92Jf1y5R8iMW8qlgkDF8EmMSrwKhPnmPGiCLwqdPTPuBNzbVbIrCghzjpZFEwoaKgHr61JbfEIm0mvI9OwvKqMrozkThSru1zOkJNvSh1CZwG22sONiaIDkyoDgymncl7r2hYrpGb4Jqo6S48WG28H4Jrgno2PGA/F+LBwDZTw055Oxoz9rcEsFXFM65PgqTJ82aQhIN1PxvSAcmTbapzykqFJYMxrDEfDe+XEyx8ogDNGsCYjlgsvsiBlNRS3bpoFgpyR3eaS950/9hdIHIPS603qHXl1qLc0nJ++/eRFO74cF3UDZJ9U6AahwfE7baseQuYeQuYeQuYeQuYeQua+6ZC5T4xY2+6HrIWAtYay8PrZ8Qezk9OrQ//g5PTqWaN4dGTtF4t0Gwqz+7wstVNKT/sUwd4xWt6c8HQ3g6WGsiFr1/1QT/OhnuZDPU32UE/zW6unSYVN4L3ErBYe3RBqFcqidI00Lv1Nm4EWR15BIuCW3LJMFwX0oL4hnGomVU4lpgJ1QlY4kmWsAxbm9m+GiIXb2xBEtRClMLzYYLGP12GOlD1p0goD+I/kDHQAaEtuH3crPck86VIB5h7LeGa0tcwIcGxR7ZwJDQinL9fQ88n19cEX/HD2dG9v1tZyNnGctvusORTcq5VC6ypC3F8ymSrwBBaxiemqhToqMlDyS2GZdKzS1sopOo8i6cShgYSSxEukWSV6BDXU+SIY8o3fp0oYKVQGDitra2HRWOjHMiL3C6AWY41NH934cdzQrF7mWDagCaWAe1ggdjSmSTWH5svUtqy3o/mT5+KpmM7EHhfPssMfnh/kU/HDbG//+SHff/bk+XT64uDw+eymAgn339MiUHgTyUvnfyCYN71axQ8hvJdoH6QROEJibYlCLy1cspY6oqe5Y4WxoMdFYBWmIb6gGPjfYy13vAaqlvNStupTUJOMeNpAvKW9WAostUbg+W3Mpdc5p7Vfeah3hXtravCFRImz0NbZYfJF030wVdNiGZaEoaV0AhMohxwSuPWMvS64dTIjx1KCZlgCZR4HMY1KeG2dMK2rEjo1/iK4s/0hpPXYycWM14WDikRV9I1GfDloGw0cOY4pZ0xpFsaIDUkGiiCma9hJU16T+AG3EQsNtb2B8Tt0+o8Jlr/T6YIPg7+T0tpRPx6Qsy0m6SU6cMlEYQgrWcMpYZAmJRlOXRu6NjGOOtQRB431DiatjR+qjpn+3tqOzYW5b/97CE9tb0h0tLR0nv6uNDwMai3oS8b9qcHQceGw43pH57lqpuSR/PqFzcYH47SuAvpjWupf8+Qa7Q/futk7Fxw+ABVaB3bbdU/bIyVuuBsccKn7iLxwX6WbiBxeD26ir8RNhPtB1qS0jFHPpPTFfEUI0oOv6MFXdD8gPfiKbo+zB1/Rg6/om/IVYTW+b81XRFCzTfuKbi/dv6DDaGDxDw6jB4fRg8OIPTiMvjWHUW2QY5G14MP7N/DnelPBh/dvwuWeOmYyW1dQ5RNz8PxEDsCpuIG9/PD+DRXwozdjYPxCsKkRHJMs9FIxqZxmNlsIz1zwBjWClDH6XrPA+29jFhi64t3foXlFN3ZCtylGsYHA1nK5HJOlapzprbatFrJrMg7WA8BnyVcYTk3hvl5NwGqDgFcMPy9WTeouby+NUUYO2IGhR4MVI4rDb+pbg8o617HTCl3tyTrQUxHbS2jhdWb4vNxch6ltL20Tc1ttCsZnjqqFTL6fJIh2utrqWEAn309CvxRqD4NaOAHd4RkbzHw/maGo9PQPdiJZ+v2kBB4Iwa6taHZrlRhksKJEXJdU0M4QJPxkxJYLAYkArtUhxohMK+tMDVZITz0YYx4sQm1rVKrGDHRFa2//0eHhk120uf7r739u2WC/d7pdKXe4X9F9CivsvwNrpJZFQCI2Zi7F1fb163faUey6VAP1SkdpeZo8nk6o0xo2c4SJONym28MzSI0r9Jxuff5TaSnD+bfauiboP1Sr9Yxtbb+fmOkVP4vDcnCCLrmNgI5ajHfQHfxJG+tHW/NzR/m3NtnJ+97zUxp+sFlnA4PblIJ0Cj2GWnMnPIgQtDW+4QpyD4m2yTWkB8fh4ZN+dunhkxZQkCW2qYPpmS9MQEQcLRwAL/6CaxtcQzwHHqcdYuvx+H8FHi8+QsHipN1EOgtkuqCEjb2/lPbfwglNTOhYXSqBHT51ofIUh/mmtYtvjZLJcLEY1BFHjF2fyso18ADo+OaEvu646lq+aDYVbilEI+YhF2upUXnoCDLUmja1t2cw+vozANxlq8NnMYt2cjQojxHeNXyqp0Bv+FabxiQkzCWFoKUm25sTFc9JB+851YYLDsGrKJegubG44lFYk8bWdrT9mBTs4FdoMRJgL04vKv6JFJaOQrjgYaMft+AKPpN5yH4NKn3M1yVJCccMvJiEpfIuAVj/QLvIN2QS+QasIf9oQ8iDDeRGG8hXZ/74ai0fVpgLPg9XooSzs+bpLfg7jhG4fBPB6S/5VAUpFL+IkoWAO/d3PiqBtNBLape6FNMYYQIBNkldTKw+wY3XFuoIatAvbs+Sse/FlzrJNFt3S+TpIoQQfKluTgmFIOp6QJ3xGTfyS15oPyja0Kt2lFFDXAPe/D9kUfDdp+M99gjR+M/s5ekHQin75YztH1zsY0PNUMvtMTuuqkL8KqZ/lW732d7T8f54/2lkJ4/++vP52zcj/OYnkV3qx4zinnb3D8Z77K2eykLs7j99vX/4gvC0+2yvW8r2oTj2INQPxbEfimN/HsT/Y4tjbxbUf+9z3TWiwXPB73b8JEdsKqBVEFfZQhv8cyfTZQlgki7xF3ynNdu/wKAvgzkCP4HPY8hkuDyAcllQKREqb/3dmvhHgLfT9GEIJdd2cqBVt0b2kI2dLMUfTbQfDswLGS2gFXeLI7qfdl4u5dxwnM+ZWrRHx7W0htXT30QW23fDHxc3ruRfohSLmIV9DF2yAJ0UVdqGADrxtwBoFKe1k7z2H3VKbUKZmjyXVCbI6+4Q50ox+TBPLBiW7iEbjihft4PXgNWAloRstzayRx39TfRElL537f7BoINk1x94kEavHR3CZAWYL0IexG1J+1xiLogUTY6OvxrR6c0KXefNQX3p/wy2D4hm55TQNoDpt/Qr6uNZ61PrSUDkIXWE5/kFvHARhgyV47RJj3Jr1fDBuDLak35jDohciH7Z+Xg9jabqLn3i6fEnreeFwBUjNQ5MLks+FwNT81Lu8GmW7x88GWSlzewnfgR28iraGBBPMbUJl/w9O/ZkgvlZRZ6ygxjSJBwfR5QAkm+gs8GXr6WzZI4AYJMqeP00cUHx/TvPdIuj05nrtucnmY3Sni4SBnP9ZPTBOPngtnORAJOFdKuLW4iN67+67axE47fduN75uu08GId4qzlarw6OH/hRrrNLoFViSK/C3wPHC3+D9KRu0gn95s+1XWjjLlD+HbEZL6xI1BWcbycyozVqRQSLDUrHdVKMJGIaizOMrARhw58MIm3NVJ7j3H024HQqbV57p1k7X95u0k+fruBTUVjPOM9/efWL1+CWzGlW8sozWSv+tQdLS51i16tU7HrVAnk6gjAOlOvleUO3P+NfA4OceH0ooVYSC/7zkJM5TggUuuAPkSfJjdcvz9IUIxlzhkRmx6uyGNN7mHbODQVqa7XTfNkxLSPo11P6+q1p2X/DEFOtC8HVLdE7azACPsdm2/vzajue1rLoT9nf0Si9t/ZfvNrf+2HrduD8csZghnZbmSFAMp2LwXNwHSzWGeGyxe2BCbOEbq2RAi/rqTBKYM4Q0eFf02cD4za/R2Wvrbk1g7KUCq/nqs1HN3LWFtDX01wX45XOh9nOnQ5zgoFKU/vuwanqAR7+qTOd6px9OHnVnwhyGyqe3d+imhH7k+m8x/I/c7JgrOtPRuzyT5/NmJOfL0peVVLN6d2tP93yFCUQkyApedUHGbxMVCv0a4M7gW0YeCMgkdEKd79b3Iy7ZqNzURV6BQGG9zpxM+6aiSFPfVYX977kZOA1U9+gB33qxHHYG6cdVvo+f14clwRM05Kl15BlYNxQYT/KlXipHZIDabuXuwgB8fG2amcoVd/r8MEGVE9a8W+60JeS7/Da6VzaTF+ll5P/jb+yV/TLiqXvseTmfaP1ZGCoVAoTHHHIdeZPem+MJqa2ufgOtsNgCcZMPaZnEYDEHjw8p7zODr3OisizBflvF2AWj171dtV6IUPRb4+EnOU1NtZ33Li6ahlvQRHWpsRkx2j9hAiCihteCiegfNNUgL3S7xs0uhcY8YYP/J8Y4CZzAM2KK6htVHHjLAZ1nZyOWNp4Q+YjiJoAv1ULJK5y7PYANskhFFIFvsrovM7c3RF5TpnFeHZpGK8mxrVdN+0nk0tr2m0bXRyPkpkf3zB10hryjjNT08cksRqXn9CCjRVwunnoAY6Q/XHn2T+8f8MW/vIJtS1gOqJWgOQ6pGe16Xht2tekNbP+GkPew/qw6AaSOF0pee0WQjmJaa8hFDqwtRkVnCDfDbGzH9tP0+kTdvP/AgAA///XkFRT" + return "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" }