From c65305b71557c3cc24d1d0e4a653beb4c736f0eb Mon Sep 17 00:00:00 2001 From: Michel Laterman <82832767+michel-laterman@users.noreply.github.com> Date: Fri, 4 Jun 2021 09:23:41 -0700 Subject: [PATCH 1/7] Change timestamp in elastic-agent-json.log ut UTC (#26016) Change encoder to force UTC timestamps in ISO-8601 for the json.log entries. --- x-pack/elastic-agent/CHANGELOG.next.asciidoc | 1 + .../elastic-agent/pkg/core/logger/logger.go | 19 ++++++++++++++++++- 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/x-pack/elastic-agent/CHANGELOG.next.asciidoc b/x-pack/elastic-agent/CHANGELOG.next.asciidoc index 914d45258bc..9b7a1f5d29d 100644 --- a/x-pack/elastic-agent/CHANGELOG.next.asciidoc +++ b/x-pack/elastic-agent/CHANGELOG.next.asciidoc @@ -68,6 +68,7 @@ - Handle case where policy doesn't contain Fleet connection information {pull}25707[25707] - Fix fleet-server.yml spec to not overwrite existing keys {pull}25741[25741] - Agent sends wrong log level to Endpoint {issue}25583[25583] +- Change timestamp in elatic-agent-json.log to use UTC {issue}25391[25391] ==== New features diff --git a/x-pack/elastic-agent/pkg/core/logger/logger.go b/x-pack/elastic-agent/pkg/core/logger/logger.go index e32c4b68088..77cc4260acc 100644 --- a/x-pack/elastic-agent/pkg/core/logger/logger.go +++ b/x-pack/elastic-agent/pkg/core/logger/logger.go @@ -8,6 +8,7 @@ import ( "fmt" "os" "path/filepath" + "time" "go.elastic.co/ecszap" "go.uber.org/zap/zapcore" @@ -23,6 +24,8 @@ import ( const agentName = "elastic-agent" +const iso8601Format = "2006-01-02T15:04:05.000Z0700" + // DefaultLogLevel used in agent and its processes. const DefaultLogLevel = logp.InfoLevel @@ -127,6 +130,20 @@ func makeInternalFileOutput(cfg *Config) (zapcore.Core, error) { return nil, errors.New("failed to create internal file rotator") } - encoder := zapcore.NewJSONEncoder(ecszap.ECSCompatibleEncoderConfig(logp.JSONEncoderConfig())) + encoderConfig := ecszap.ECSCompatibleEncoderConfig(logp.JSONEncoderConfig()) + encoderConfig.EncodeTime = utcTimestampEncode + encoder := zapcore.NewJSONEncoder(encoderConfig) return ecszap.WrapCore(zapcore.NewCore(encoder, rotator, cfg.Level.ZapLevel())), nil } + +// utcTimestampEncode is a zapcore.TimeEncoder that formats time.Time in ISO-8601 in UTC. +func utcTimestampEncode(t time.Time, enc zapcore.PrimitiveArrayEncoder) { + type appendTimeEncoder interface { + AppendTimeLayout(time.Time, string) + } + if enc, ok := enc.(appendTimeEncoder); ok { + enc.AppendTimeLayout(t.UTC(), iso8601Format) + return + } + enc.AppendString(t.UTC().Format(iso8601Format)) +} From 0ba849c3911098f5b4ce9fb2d63332d92846a260 Mon Sep 17 00:00:00 2001 From: kaiyan-sheng Date: Sat, 5 Jun 2021 00:58:05 +0800 Subject: [PATCH 2/7] Migrate rds metricset to use cloudwatch input as light weight module (#26077) --- CHANGELOG.next.asciidoc | 1 + metricbeat/docs/modules/aws/rds.asciidoc | 1 + x-pack/metricbeat/include/list.go | 1 - .../cloudwatch/ec2/{metadata.go => ec2.go} | 0 .../module/aws/cloudwatch/metadata.go | 4 + .../module/aws/cloudwatch/rds/rds.go | 74 ++++ .../metricbeat/module/aws/ec2/_meta/data.json | 83 ++-- x-pack/metricbeat/module/aws/ec2/manifest.yml | 2 + x-pack/metricbeat/module/aws/module.yml | 1 + .../metricbeat/module/aws/rds/_meta/data.json | 80 ++-- x-pack/metricbeat/module/aws/rds/data.go | 109 ------ x-pack/metricbeat/module/aws/rds/manifest.yml | 222 +++++++++++ x-pack/metricbeat/module/aws/rds/rds.go | 359 ------------------ .../module/aws/rds/rds_integration_test.go | 7 +- x-pack/metricbeat/module/aws/rds/rds_test.go | 276 +------------- 15 files changed, 419 insertions(+), 801 deletions(-) rename x-pack/metricbeat/module/aws/cloudwatch/ec2/{metadata.go => ec2.go} (100%) create mode 100644 x-pack/metricbeat/module/aws/cloudwatch/rds/rds.go delete mode 100644 x-pack/metricbeat/module/aws/rds/data.go create mode 100644 x-pack/metricbeat/module/aws/rds/manifest.yml delete mode 100644 x-pack/metricbeat/module/aws/rds/rds.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index b71219e397d..40506f5bbbf 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -940,6 +940,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add additional network metrics to docker/network {pull}25354[25354] - Migrate ec2 metricsets to use cloudwatch input. {pull}25924[25924] - Reduce number of requests done by kubernetes metricsets to kubelet. {pull}25782[25782] +- Migrate rds metricsets to use cloudwatch input. {pull}26077[26077] - Migrate sqs metricsets to use cloudwatch input. {pull}26117[26117] *Packetbeat* diff --git a/metricbeat/docs/modules/aws/rds.asciidoc b/metricbeat/docs/modules/aws/rds.asciidoc index 41aa085518f..6cde9bda807 100644 --- a/metricbeat/docs/modules/aws/rds.asciidoc +++ b/metricbeat/docs/modules/aws/rds.asciidoc @@ -8,6 +8,7 @@ This file is generated! See scripts/mage/docs_collector.go include::../../../../x-pack/metricbeat/module/aws/rds/_meta/docs.asciidoc[] +This is a default metricset. If the host module is unconfigured, this metricset is enabled by default. ==== Fields diff --git a/x-pack/metricbeat/include/list.go b/x-pack/metricbeat/include/list.go index 7df3285fae8..856c3357746 100644 --- a/x-pack/metricbeat/include/list.go +++ b/x-pack/metricbeat/include/list.go @@ -14,7 +14,6 @@ import ( _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws" _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/billing" _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch" - _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/rds" _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/awsfargate" _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/awsfargate/task_stats" _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/azure" diff --git a/x-pack/metricbeat/module/aws/cloudwatch/ec2/metadata.go b/x-pack/metricbeat/module/aws/cloudwatch/ec2/ec2.go similarity index 100% rename from x-pack/metricbeat/module/aws/cloudwatch/ec2/metadata.go rename to x-pack/metricbeat/module/aws/cloudwatch/ec2/ec2.go diff --git a/x-pack/metricbeat/module/aws/cloudwatch/metadata.go b/x-pack/metricbeat/module/aws/cloudwatch/metadata.go index d91e50e9c0a..1c9aac5016a 100644 --- a/x-pack/metricbeat/module/aws/cloudwatch/metadata.go +++ b/x-pack/metricbeat/module/aws/cloudwatch/metadata.go @@ -9,12 +9,14 @@ import ( "github.com/elastic/beats/v7/metricbeat/mb" "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/ec2" + "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/rds" "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch/sqs" ) // AWS namespaces const ( namespaceEC2 = "AWS/EC2" + namespaceRDS = "AWS/RDS" namespaceSQS = "AWS/SQS" ) @@ -23,6 +25,8 @@ func addMetadata(namespace string, endpoint string, regionName string, awsConfig switch namespace { case namespaceEC2: return ec2.AddMetadata(endpoint, regionName, awsConfig, events) + case namespaceRDS: + return rds.AddMetadata(endpoint, regionName, awsConfig, events) case namespaceSQS: return sqs.AddMetadata(endpoint, regionName, awsConfig, events) default: diff --git a/x-pack/metricbeat/module/aws/cloudwatch/rds/rds.go b/x-pack/metricbeat/module/aws/cloudwatch/rds/rds.go new file mode 100644 index 00000000000..29d9fee6701 --- /dev/null +++ b/x-pack/metricbeat/module/aws/cloudwatch/rds/rds.go @@ -0,0 +1,74 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package rds + +import ( + "context" + "fmt" + + awssdk "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/rds" + "github.com/aws/aws-sdk-go-v2/service/rds/rdsiface" + "github.com/pkg/errors" + + "github.com/elastic/beats/v7/libbeat/logp" + "github.com/elastic/beats/v7/metricbeat/mb" + awscommon "github.com/elastic/beats/v7/x-pack/libbeat/common/aws" + "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws" +) + +const metadataPrefix = "aws.rds.db_instance." + +// DBDetails holds detailed information from DescribeDBInstances for each rds. +type DBDetails struct { + dbArn string + dbClass string + dbAvailabilityZone string + dbIdentifier string + dbStatus string + tags []aws.Tag +} + +// AddMetadata adds metadata for RDS instances from a specific region +func AddMetadata(endpoint string, regionName string, awsConfig awssdk.Config, events map[string]mb.Event) map[string]mb.Event { + svc := rds.New(awscommon.EnrichAWSConfigWithEndpoint( + endpoint, "rds", regionName, awsConfig)) + + // Get DBInstance IDs per region + dbDetailsMap, err := getDBInstancesPerRegion(svc) + if err != nil { + logp.Error(fmt.Errorf("getInstancesPerRegion failed, skipping region %s: %w", regionName, err)) + return events + } + + for identifier, output := range dbDetailsMap { + if _, ok := events[identifier]; !ok { + continue + } + events[identifier].RootFields.Put(metadataPrefix+"arn", &output.DBInstanceArn) + events[identifier].RootFields.Put(metadataPrefix+"status", &output.DBInstanceStatus) + events[identifier].RootFields.Put(metadataPrefix+"identifier", &output.DBInstanceIdentifier) + events[identifier].RootFields.Put(metadataPrefix+"db_cluster_identifier", &output.DBClusterIdentifier) + events[identifier].RootFields.Put(metadataPrefix+"class", &output.DBInstanceClass) + events[identifier].RootFields.Put(metadataPrefix+"engine_name", &output.Engine) + events[identifier].RootFields.Put("cloud.availability_zone", &output.AvailabilityZone) + } + return events +} + +func getDBInstancesPerRegion(svc rdsiface.ClientAPI) (map[string]*rds.DBInstance, error) { + describeInstanceInput := &rds.DescribeDBInstancesInput{} + req := svc.DescribeDBInstancesRequest(describeInstanceInput) + output, err := req.Send(context.TODO()) + if err != nil { + return nil, errors.Wrap(err, "Error DescribeDBInstancesRequest") + } + + instancesOutputs := map[string]*rds.DBInstance{} + for _, dbInstance := range output.DBInstances { + instancesOutputs[*dbInstance.DBInstanceIdentifier] = &dbInstance + } + return instancesOutputs, nil +} diff --git a/x-pack/metricbeat/module/aws/ec2/_meta/data.json b/x-pack/metricbeat/module/aws/ec2/_meta/data.json index a0afcf89fc2..318049546a1 100644 --- a/x-pack/metricbeat/module/aws/ec2/_meta/data.json +++ b/x-pack/metricbeat/module/aws/ec2/_meta/data.json @@ -5,16 +5,30 @@ "namespace": "AWS/EC2" }, "dimensions": { - "InstanceId": "i-0853c3c24739b4696" + "InstanceId": "i-0830bfecfa7173cbe" }, "ec2": { "cpu": { - "credit_balance": 288, - "credit_usage": 0.008267983333333333, + "credit_balance": 144, + "credit_usage": 0.032965, "surplus_credit_balance": 0, "surplus_credits_charged": 0, "total": { - "pct": 0.08999900021110921 + "pct": 0.6973418542208679 + } + }, + "diskio": { + "read": { + "bytes": 0, + "bytes_per_sec": 0, + "count": 0, + "count_per_sec": 0 + }, + "write": { + "bytes": 0, + "bytes_per_sec": 0, + "count": 0, + "count_per_sec": 0 } }, "instance": { @@ -22,37 +36,37 @@ "count": 1 }, "image": { - "id": "ami-067349b5a5143523d" + "id": "ami-0ce21b51cb31a48b8" }, "monitoring": { "state": "disabled" }, "private": { - "dns_name": "ip-172-31-41-189.eu-north-1.compute.internal", - "ip": "172.31.41.189" + "dns_name": "ip-172-31-22-253.us-west-2.compute.internal", + "ip": "172.31.22.253" }, "public": { - "dns_name": "ec2-13-48-192-116.eu-north-1.compute.amazonaws.com", - "ip": "13.48.192.116" + "dns_name": "ec2-54-202-50-183.us-west-2.compute.amazonaws.com", + "ip": "54.202.50.183" }, "state": { "code": 16, "name": "running" }, - "threads_per_core": 2 + "threads_per_core": 1 }, "network": { "in": { - "bytes": 5259, - "bytes_per_sec": 17.53, - "packets": 31, - "packets_per_sec": 0.10333333333333333 + "bytes": 18805, + "bytes_per_sec": 62.68333333333333, + "packets": 122, + "packets_per_sec": 0.4066666666666667 }, "out": { - "bytes": 12879, - "bytes_per_sec": 42.93, - "packets": 34, - "packets_per_sec": 0.11333333333333333 + "bytes": 37121, + "bytes_per_sec": 123.73666666666666, + "packets": 119, + "packets_per_sec": 0.39666666666666667 } }, "status": { @@ -60,6 +74,9 @@ "check_failed_instance": 0, "check_failed_system": 0 } + }, + "tags": { + "platform": "amazon_linux" } }, "cloud": { @@ -67,15 +84,15 @@ "id": "428152502467", "name": "elastic-beats" }, - "availability_zone": "eu-north-1b", + "availability_zone": "us-west-2b", "instance": { - "id": "i-0853c3c24739b4696" + "id": "i-0830bfecfa7173cbe" }, "machine": { - "type": "t3.micro" + "type": "t2.micro" }, "provider": "aws", - "region": "eu-north-1" + "region": "us-west-2" }, "event": { "dataset": "aws.ec2", @@ -84,18 +101,26 @@ }, "host": { "cpu": { - "usage": 0.08999900021110921 + "usage": 0.6973418542208679 + }, + "disk": { + "read": { + "bytes": 0 + }, + "write": { + "bytes": 0 + } }, - "id": "i-0853c3c24739b4696", - "name": "i-0853c3c24739b4696", + "id": "i-0830bfecfa7173cbe", + "name": "i-0830bfecfa7173cbe", "network": { "egress": { - "bytes": 12879, - "packets": 34 + "bytes": 37121, + "packets": 119 }, "ingress": { - "bytes": 5259, - "packets": 31 + "bytes": 18805, + "packets": 122 } } }, diff --git a/x-pack/metricbeat/module/aws/ec2/manifest.yml b/x-pack/metricbeat/module/aws/ec2/manifest.yml index fe914e5c37b..539b7fec914 100644 --- a/x-pack/metricbeat/module/aws/ec2/manifest.yml +++ b/x-pack/metricbeat/module/aws/ec2/manifest.yml @@ -5,6 +5,7 @@ input: defaults: metrics: - namespace: AWS/EC2 + resource_type: ec2:instance statistic: ["Average"] name: - CPUUtilization @@ -16,6 +17,7 @@ input: - StatusCheckFailed_Instance - StatusCheckFailed_System - namespace: AWS/EC2 + resource_type: ec2:instance statistic: ["Sum" ] name: - DiskReadBytes diff --git a/x-pack/metricbeat/module/aws/module.yml b/x-pack/metricbeat/module/aws/module.yml index 71e476b6426..1f68157f87b 100644 --- a/x-pack/metricbeat/module/aws/module.yml +++ b/x-pack/metricbeat/module/aws/module.yml @@ -3,6 +3,7 @@ metricsets: - ec2 - elb - ebs + - rds - sqs - usage - sns diff --git a/x-pack/metricbeat/module/aws/rds/_meta/data.json b/x-pack/metricbeat/module/aws/rds/_meta/data.json index 35d89c69fb7..76cfd2aa3e7 100644 --- a/x-pack/metricbeat/module/aws/rds/_meta/data.json +++ b/x-pack/metricbeat/module/aws/rds/_meta/data.json @@ -1,53 +1,69 @@ { "@timestamp": "2017-10-12T08:05:34.853Z", "aws": { + "cloudwatch": { + "namespace": "AWS/RDS" + }, + "dimensions": { + "DBClusterIdentifier": "database-1", + "Role": "WRITER" + }, "rds": { "aurora_bin_log_replica_lag": 0, - "aurora_replica.lag_max.ms": 19.108999252319336, - "aurora_replica.lag_min.ms": 19.108999252319336, - "cache_hit_ratio.buffer": 100, - "cache_hit_ratio.result_set": 0, + "aurora_replica": { + "lag_max": { + "ms": 13.449000358581543 + }, + "lag_min": { + "ms": 13.449000358581543 + } + }, + "aurora_volume_left_total": { + "bytes": 70007366615040 + }, + "cache_hit_ratio": { + "buffer": 100, + "result_set": 0 + }, "cpu": { "total": { - "pct": 0.04 + "pct": 6.975116251937533 } }, "database_connections": 0, - "db_instance": { - "arn": "arn:aws:rds:us-east-1:428152502467:db:database-1-instance-1", - "class": "db.r5.large", - "identifier": "database-1-instance-1", - "status": "available" - }, - "db_instance.identifier": "database-1-instance-1", "deadlocks": 0, - "disk_usage": { - "bin_log.bytes": 0 + "engine_uptime": { + "sec": 20413803 + }, + "free_local_storage": { + "bytes": 25608523776 + }, + "freeable_memory": { + "bytes": 4695093248 }, - "engine_uptime.sec": 2704277, - "free_local_storage.bytes": 31745863680, - "freeable_memory.bytes": 4634234880, "latency": { - "commit": 5.270933333333333, + "commit": 5.198533333333333, "ddl": 0, "delete": 0, - "dml": 0.1624, - "insert": 0.1624, - "select": 0.17333862433862435, - "update": 0 + "dml": 0.19726666666666667, + "insert": 0.19726666666666667, + "read": 0, + "select": 0.21317204301075268, + "update": 0, + "write": 0.0013534145331858408 }, "login_failures": 0, - "queries": 9.11833836203304, + "queries": 8.830095631601747, "throughput": { - "commit": 0.5000916834753039, + "commit": 0.49980840677740196, "ddl": 0, "delete": 0, - "dml": 0.5000916834753039, - "insert": 0.5000916834753039, - "network": 1.4, - "network_receive": 0.7, - "network_transmit": 0.7, - "select": 3.150577605894414, + "dml": 0.49980840677740196, + "insert": 0.49980840677740196, + "network": 1.3998600139986002, + "network_receive": 0.6999300069993001, + "network_transmit": 0.6999300069993001, + "select": 3.098812122019892, "update": 0 }, "transactions": { @@ -56,8 +72,9 @@ } }, "tags": { + "cluster": "database-1", "created-by": "ks", - "dept": "engr" + "dept": "eng" } }, "cloud": { @@ -65,7 +82,6 @@ "id": "428152502467", "name": "elastic-beats" }, - "availability_zone": "us-east-1b", "provider": "aws", "region": "us-east-1" }, diff --git a/x-pack/metricbeat/module/aws/rds/data.go b/x-pack/metricbeat/module/aws/rds/data.go deleted file mode 100644 index 273626d3b1b..00000000000 --- a/x-pack/metricbeat/module/aws/rds/data.go +++ /dev/null @@ -1,109 +0,0 @@ -// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one -// or more contributor license agreements. Licensed under the Elastic License; -// you may not use this file except in compliance with the Elastic License. - -package rds - -import ( - s "github.com/elastic/beats/v7/libbeat/common/schema" - c "github.com/elastic/beats/v7/libbeat/common/schema/mapstrstr" -) - -var ( - schemaMetricSetFields = s.Schema{ - "burst_balance.pct": c.Float("BurstBalance"), - "cpu": s.Object{ - "total": s.Object{ - "pct": c.Float("CPUUtilization"), - }, - "credit_usage": c.Float("CPUCreditUsage"), - "credit_balance": c.Float("CPUCreditBalance"), - }, - "database_connections": c.Float("DatabaseConnections"), - "disk_queue_depth": c.Float("DiskQueueDepth"), - "failed_sql_server_agent_jobs": c.Float("FailedSQLServerAgentJobsCount"), - "freeable_memory.bytes": c.Float("FreeableMemory"), - "free_storage.bytes": c.Float("FreeStorageSpace"), - "maximum_used_transaction_ids": c.Float("MaximumUsedTransactionIDs"), - "oldest_replication_slot_lag.mb": c.Float("OldestReplicationSlotLag"), - "read_io.ops_per_sec": c.Float("ReadIOPS"), - "throughput": s.Object{ - "commit": c.Float("CommitThroughput"), - "delete": c.Float("DeleteThroughput"), - "ddl": c.Float("DDLThroughput"), - "dml": c.Float("DMLThroughput"), - "insert": c.Float("InsertThroughput"), - "network": c.Float("NetworkThroughput"), - "network_receive": c.Float("NetworkReceiveThroughput"), - "network_transmit": c.Float("NetworkTransmitThroughput"), - "read": c.Float("ReadThroughput"), - "select": c.Float("SelectThroughput"), - "update": c.Float("UpdateThroughput"), - "write": c.Float("WriteThroughput"), - }, - "latency": s.Object{ - "commit": c.Float("CommitLatency"), - "ddl": c.Float("DDLLatency"), - "dml": c.Float("DMLLatency"), - "insert": c.Float("InsertLatency"), - "read": c.Float("ReadLatency"), - "select": c.Float("SelectLatency"), - "update": c.Float("UpdateLatency"), - "write": c.Float("WriteLatency"), - "delete": c.Float("DeleteLatency"), - }, - "replica_lag.sec": c.Float("ReplicaLag"), - "disk_usage": s.Object{ - "bin_log.bytes": c.Float("BinLogDiskUsage"), - "replication_slot.mb": c.Float("ReplicationSlotDiskUsage"), - "transaction_logs.mb": c.Float("TransactionLogsDiskUsage"), - }, - "swap_usage.bytes": c.Float("SwapUsage"), - "transaction_logs_generation": c.Float("TransactionLogsGeneration"), - "write_io.ops_per_sec": c.Float("WriteIOPS"), - "queries": c.Float("Queries"), - "deadlocks": c.Float("Deadlocks"), - "volume_used.bytes": c.Float("VolumeBytesUsed"), - "free_local_storage.bytes": c.Float("FreeLocalStorage"), - "transactions": s.Object{ - "active": c.Float("ActiveTransactions"), - "blocked": c.Float("BlockedTransactions"), - }, - "login_failures": c.Float("LoginFailures"), - - "db_instance.identifier": c.Str("DBInstanceIdentifier"), - "db_instance.db_cluster_identifier": c.Str("DBClusterIdentifier"), - "db_instance.class": c.Str("DatabaseClass"), - "db_instance.role": c.Str("Role"), - "db_instance.engine_name": c.Str("EngineName"), - - "aurora_bin_log_replica_lag": c.Float("AuroraBinlogReplicaLag"), - - "aurora_global_db.replicated_write_io.bytes": c.Float("AuroraGlobalDBReplicatedWriteIO"), - "aurora_global_db.data_transfer.bytes": c.Float("AuroraGlobalDBDataTransferBytes"), - "aurora_global_db.replication_lag.ms": c.Float("AuroraGlobalDBReplicationLag"), - - "aurora_replica.lag.ms": c.Float("AuroraReplicaLag"), - "aurora_replica.lag_max.ms": c.Float("AuroraReplicaLagMaximum"), - "aurora_replica.lag_min.ms": c.Float("AuroraReplicaLagMinimum"), - - "backtrack_change_records.creation_rate": c.Float("BacktrackChangeRecordsCreationRate"), - "backtrack_change_records.stored": c.Float("BacktrackChangeRecordsStored"), - - "backtrack_window.actual": c.Float("BacktrackWindowActual"), - "backtrack_window.alert": c.Float("BacktrackWindowAlert"), - - "storage_used.backup_retention_period.bytes": c.Float("BackupRetentionPeriodStorageUsed"), - "storage_used.snapshot.bytes": c.Float("SnapshotStorageUsed"), - - "cache_hit_ratio.buffer": c.Float("BufferCacheHitRatio"), - "cache_hit_ratio.result_set": c.Float("ResultSetCacheHitRatio"), - - "engine_uptime.sec": c.Float("EngineUptime"), - "volume.read.iops": c.Float("VolumeReadIOPs"), - "volume.write.iops": c.Float("VolumeWriteIOPs"), - "rds_to_aurora_postgresql_replica_lag.sec": c.Float("RDSToAuroraPostgreSQLReplicaLag"), - "backup_storage_billed_total.bytes": c.Float("TotalBackupStorageBilled"), - "aurora_volume_left_total.bytes": c.Float("AuroraVolumeBytesLeftTotal"), - } -) diff --git a/x-pack/metricbeat/module/aws/rds/manifest.yml b/x-pack/metricbeat/module/aws/rds/manifest.yml new file mode 100644 index 00000000000..36f2a509811 --- /dev/null +++ b/x-pack/metricbeat/module/aws/rds/manifest.yml @@ -0,0 +1,222 @@ +default: true +input: + module: aws + metricset: cloudwatch + defaults: + metrics: + - namespace: AWS/RDS + resource_type: rds + statistic: ["Average"] + name: + - BurstBalance + - CPUUtilization + - CPUCreditUsage + - CPUCreditBalance + - DatabaseConnections + - DiskQueueDepth + - FailedSQLServerAgentJobsCount + - FreeableMemory + - FreeStorageSpace + - MaximumUsedTransactionIDs + - OldestReplicationSlotLag + - ReadIOPS + - CommitThroughput + - DeleteThroughput + - DDLThroughput + - DMLThroughput + - InsertThroughput + - NetworkThroughput + - NetworkReceiveThroughput + - NetworkTransmitThroughput + - ReadThroughput + - SelectThroughput + - UpdateThroughput + - WriteThroughput + - CommitLatency + - DDLLatency + - DMLLatency + - InsertLatency + - ReadLatency + - SelectLatency + - UpdateLatency + - WriteLatency + - DeleteLatency + - ReplicaLag + - BinLogDiskUsage + - ReplicationSlotDiskUsage + - TransactionLogsDiskUsage + - SwapUsage + - TransactionLogsGeneration + - WriteIOPS + - Queries + - Deadlocks + - VolumeBytesUsed + - FreeLocalStorage + - ActiveTransactions + - BlockedTransactions + - LoginFailures + - AuroraBinlogReplicaLag + - AuroraGlobalDBReplicatedWriteIO + - AuroraGlobalDBDataTransferBytes + - AuroraGlobalDBReplicationLag + - AuroraReplicaLag + - AuroraReplicaLagMaximum + - AuroraReplicaLagMinimum + - BacktrackChangeRecordsCreationRate + - BacktrackChangeRecordsStored + - BacktrackWindowActual + - BacktrackWindowAlert + - BackupRetentionPeriodStorageUsed + - SnapshotStorageUsed + - BufferCacheHitRatio + - ResultSetCacheHitRatio + - EngineUptime + - VolumeReadIOPs + - VolumeWriteIOPs + - RDSToAuroraPostgreSQLReplicaLag + - TotalBackupStorageBilled + - AuroraVolumeBytesLeftTotal +processors: + - rename: + ignore_missing: true + fields: + - from: "aws.rds.metrics.BurstBalance.avg" + to: "aws.rds.burst_balance.pct" + - from: "aws.rds.metrics.CPUUtilization.avg" + to: "aws.rds.cpu.total.pct" + - from: "aws.rds.metrics.CPUCreditUsage.avg" + to: "aws.rds.cpu.credit_usage" + - from: "aws.rds.metrics.CPUCreditBalance.avg" + to: "aws.rds.cpu.credit_balance" + - from: "aws.rds.metrics.DatabaseConnections.avg" + to: "aws.rds.database_connections" + - from: "aws.rds.metrics.DiskQueueDepth.avg" + to: "aws.rds.disk_queue_depth" + - from: "aws.rds.metrics.FailedSQLServerAgentJobsCount.avg" + to: "aws.rds.failed_sql_server_agent_jobs" + - from: "aws.rds.metrics.FreeableMemory.avg" + to: "aws.rds.freeable_memory.bytes" + - from: "aws.rds.metrics.FreeStorageSpace.avg" + to: "aws.rds.free_storage.bytes" + - from: "aws.rds.metrics.MaximumUsedTransactionIDs.avg" + to: "aws.rds.maximum_used_transaction_ids" + - from: "aws.rds.metrics.OldestReplicationSlotLag.avg" + to: "aws.rds.oldest_replication_slot_lag.mb" + - from: "aws.rds.metrics.ReadIOPS.avg" + to: "aws.rds.read_io.ops_per_sec" + - from: "aws.rds.metrics.CommitThroughput.avg" + to: "aws.rds.throughput.commit" + - from: "aws.rds.metrics.DeleteThroughput.avg" + to: "aws.rds.throughput.delete" + - from: "aws.rds.metrics.DDLThroughput.avg" + to: "aws.rds.throughput.ddl" + - from: "aws.rds.metrics.DMLThroughput.avg" + to: "aws.rds.throughput.dml" + - from: "aws.rds.metrics.InsertThroughput.avg" + to: "aws.rds.throughput.insert" + - from: "aws.rds.metrics.NetworkThroughput.avg" + to: "aws.rds.throughput.network" + - from: "aws.rds.metrics.NetworkReceiveThroughput.avg" + to: "aws.rds.throughput.network_receive" + - from: "aws.rds.metrics.NetworkTransmitThroughput.avg" + to: "aws.rds.throughput.network_transmit" + - from: "aws.rds.metrics.ReadThroughput.avg" + to: "aws.rds.throughput.read" + - from: "aws.rds.metrics.SelectThroughput.avg" + to: "aws.rds.throughput.select" + - from: "aws.rds.metrics.UpdateThroughput.avg" + to: "aws.rds.throughput.update" + - from: "aws.rds.metrics.WriteThroughput.avg" + to: "aws.rds.throughput.write" + - from: "aws.rds.metrics.CommitLatency.avg" + to: "aws.rds.latency.commit" + - from: "aws.rds.metrics.DDLLatency.avg" + to: "aws.rds.latency.ddl" + - from: "aws.rds.metrics.DMLLatency.avg" + to: "aws.rds.latency.dml" + - from: "aws.rds.metrics.InsertLatency.avg" + to: "aws.rds.latency.insert" + - from: "aws.rds.metrics.ReadLatency.avg" + to: "aws.rds.latency.read" + - from: "aws.rds.metrics.SelectLatency.avg" + to: "aws.rds.latency.select" + - from: "aws.rds.metrics.UpdateLatency.avg" + to: "aws.rds.latency.update" + - from: "aws.rds.metrics.WriteLatency.avg" + to: "aws.rds.latency.write" + - from: "aws.rds.metrics.DeleteLatency.avg" + to: "aws.rds.latency.delete" + - from: "aws.rds.metrics.ReplicaLag.avg" + to: "aws.rds.replica_lag.sec" + - from: "aws.rds.metrics.BinLogDiskUsage.avg" + to: "aws.rds.disk_usage.bin_log.bytes" + - from: "aws.rds.metrics.ReplicationSlotDiskUsage.avg" + to: "aws.rds.disk_usage.replication_slot.mb" + - from: "aws.rds.metrics.TransactionLogsDiskUsage.avg" + to: "aws.rds.disk_usage.transaction_logs.mb" + - from: "aws.rds.metrics.SwapUsage.avg" + to: "aws.rds.swap_usage.bytes" + - from: "aws.rds.metrics.TransactionLogsGeneration.avg" + to: "aws.rds.transaction_logs_generation" + - from: "aws.rds.metrics.WriteIOPS.avg" + to: "aws.rds.write_io.ops_per_sec" + - from: "aws.rds.metrics.Queries.avg" + to: "aws.rds.queries" + - from: "aws.rds.metrics.Deadlocks.avg" + to: "aws.rds.deadlocks" + - from: "aws.rds.metrics.VolumeBytesUsed.avg" + to: "aws.rds.volume_used.bytes" + - from: "aws.rds.metrics.FreeLocalStorage.avg" + to: "aws.rds.free_local_storage.bytes" + - from: "aws.rds.metrics.ActiveTransactions.avg" + to: "aws.rds.transactions.active" + - from: "aws.rds.metrics.BlockedTransactions.avg" + to: "aws.rds.transactions.blocked" + - from: "aws.rds.metrics.LoginFailures.avg" + to: "aws.rds.login_failures" + - from: "aws.rds.metrics.AuroraBinlogReplicaLag.avg" + to: "aws.rds.aurora_bin_log_replica_lag" + - from: "aws.rds.metrics.aurora_bin_log_replica_lag.avg" + to: "aws.rds.aurora_global_db.replicated_write_io.bytes" + - from: "aws.rds.metrics.AuroraGlobalDBDataTransferBytes.avg" + to: "aws.rds.aurora_global_db.data_transfer.bytes" + - from: "aws.rds.metrics.AuroraGlobalDBReplicationLag.avg" + to: "aws.rds.aurora_global_db.replication_lag.ms" + - from: "aws.rds.metrics.AuroraReplicaLag.avg" + to: "aws.rds.aurora_replica.lag.ms" + - from: "aws.rds.metrics.AuroraReplicaLagMaximum.avg" + to: "aws.rds.aurora_replica.lag_max.ms" + - from: "aws.rds.metrics.AuroraReplicaLagMinimum.avg" + to: "aws.rds.aurora_replica.lag_min.ms" + - from: "aws.rds.metrics.BacktrackChangeRecordsCreationRate.avg" + to: "aws.rds.backtrack_change_records.creation_rate" + - from: "aws.rds.metrics.BacktrackChangeRecordsStored.avg" + to: "aws.rds.backtrack_change_records.stored" + - from: "aws.rds.metrics.BacktrackWindowActual.avg" + to: "aws.rds.backtrack_window.actual" + - from: "aws.rds.metrics.BacktrackWindowAlert.avg" + to: "aws.rds.backtrack_window.alert" + - from: "aws.rds.metrics.BackupRetentionPeriodStorageUsed.avg" + to: "aws.rds.storage_used.backup_retention_period.bytes" + - from: "aws.rds.metrics.SnapshotStorageUsed.avg" + to: "aws.rds.storage_used.snapshot.bytes" + - from: "aws.rds.metrics.BufferCacheHitRatio.avg" + to: "aws.rds.cache_hit_ratio.buffer" + - from: "aws.rds.metrics.ResultSetCacheHitRatio.avg" + to: "aws.rds.cache_hit_ratio.result_set" + - from: "aws.rds.metrics.EngineUptime.avg" + to: "aws.rds.engine_uptime.sec" + - from: "aws.rds.metrics.VolumeReadIOPs.avg" + to: "aws.rds.volume.read.iops" + - from: "aws.rds.metrics.VolumeWriteIOPs.avg" + to: "aws.rds.volume.write.iops" + - from: "aws.rds.metrics.RDSToAuroraPostgreSQLReplicaLag.avg" + to: "aws.rds.rds_to_aurora_postgresql_replica_lag.sec" + - from: "aws.rds.metrics.TotalBackupStorageBilled.avg" + to: "aws.rds.backup_storage_billed_total.bytes" + - from: "aws.rds.metrics.AuroraVolumeBytesLeftTotal.avg" + to: "aws.rds.aurora_volume_left_total.bytes" + - drop_fields: + ignore_missing: true + fields: + - "aws.rds.metrics" diff --git a/x-pack/metricbeat/module/aws/rds/rds.go b/x-pack/metricbeat/module/aws/rds/rds.go deleted file mode 100644 index 3bb14f28de8..00000000000 --- a/x-pack/metricbeat/module/aws/rds/rds.go +++ /dev/null @@ -1,359 +0,0 @@ -// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one -// or more contributor license agreements. Licensed under the Elastic License; -// you may not use this file except in compliance with the Elastic License. - -package rds - -import ( - "context" - "fmt" - "strconv" - "strings" - "time" - - "github.com/aws/aws-sdk-go-v2/service/cloudwatch" - "github.com/aws/aws-sdk-go-v2/service/rds" - "github.com/aws/aws-sdk-go-v2/service/rds/rdsiface" - "github.com/pkg/errors" - - "github.com/elastic/beats/v7/libbeat/common" - "github.com/elastic/beats/v7/metricbeat/mb" - awscommon "github.com/elastic/beats/v7/x-pack/libbeat/common/aws" - "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws" -) - -var ( - metricsetName = "rds" - metricNameIdx = 0 -) - -// init registers the MetricSet with the central registry as soon as the program -// starts. The New function will be called later to instantiate an instance of -// the MetricSet for each host defined in the module's configuration. After the -// MetricSet has been created then Fetch will begin to be called periodically. -func init() { - mb.Registry.MustAddMetricSet(aws.ModuleName, metricsetName, New) -} - -// MetricSet holds any configuration or state information. It must implement -// the mb.MetricSet interface. And this is best achieved by embedding -// mb.BaseMetricSet because it implements all of the required mb.MetricSet -// interface methods except for Fetch. -type MetricSet struct { - *aws.MetricSet -} - -// DBDetails holds detailed information from DescribeDBInstances for each rds. -type DBDetails struct { - dbArn string - dbClass string - dbAvailabilityZone string - dbIdentifier string - dbStatus string - tags []aws.Tag -} - -// New creates a new instance of the MetricSet. New is responsible for unpacking -// any MetricSet specific configuration options if there are any. -func New(base mb.BaseMetricSet) (mb.MetricSet, error) { - metricSet, err := aws.NewMetricSet(base) - if err != nil { - return nil, errors.Wrap(err, "error creating aws metricset") - } - - // Check if period is set to be multiple of 60s - remainder := int(metricSet.Period.Seconds()) % 60 - if remainder != 0 { - err := errors.New("Period needs to be set to 60s (or a multiple of 60s). To avoid data missing or " + - "extra costs, please make sure period is set correctly in config.yml") - base.Logger().Info(err) - } - - return &MetricSet{ - MetricSet: metricSet, - }, nil -} - -// Fetch methods implements the data gathering and data conversion to the right -// format. It publishes the event which is then forwarded to the output. In case -// of an error set the Error field of mb.Event or simply call report.Error(). -func (m *MetricSet) Fetch(report mb.ReporterV2) error { - // Get startTime and endTime - startTime, endTime := aws.GetStartTimeEndTime(m.Period, m.Latency) - m.Logger().Debugf("startTime = %s, endTime = %s", startTime, endTime) - - for _, regionName := range m.MetricSet.RegionsList { - awsConfig := m.MetricSet.AwsConfig.Copy() - awsConfig.Region = regionName - - svc := rds.New(awscommon.EnrichAWSConfigWithEndpoint( - m.Endpoint, "rds", regionName, awsConfig)) - - // Get DBInstance IDs per region - dbInstanceIDs, dbDetailsMap, err := m.getDBInstancesPerRegion(svc) - if err != nil { - err = errors.Wrap(err, "getDBInstancesPerRegion failed, skipping region "+regionName) - m.Logger().Errorf(err.Error()) - report.Error(err) - continue - } - - if len(dbInstanceIDs) == 0 { - continue - } - - svcCloudwatch := cloudwatch.New(awscommon.EnrichAWSConfigWithEndpoint( - m.Endpoint, "monitoring", regionName, awsConfig)) - - namespace := "AWS/RDS" - listMetricsOutput, err := aws.GetListMetricsOutput(namespace, regionName, svcCloudwatch) - if err != nil { - m.Logger().Error(err.Error()) - report.Error(err) - continue - } - - if listMetricsOutput == nil || len(listMetricsOutput) == 0 { - continue - } - - // Get MetricDataQuery for all dbInstances per region - metricDataQueriesTotal := constructMetricQueries(listMetricsOutput, m.Period) - var metricDataOutput []cloudwatch.MetricDataResult - if len(metricDataQueriesTotal) != 0 { - // Use metricDataQueries to make GetMetricData API calls - metricDataOutput, err = aws.GetMetricDataResults(metricDataQueriesTotal, svcCloudwatch, startTime, endTime) - if err != nil { - err = errors.Wrap(err, "GetMetricDataResults failed, skipping region "+regionName) - m.Logger().Error(err.Error()) - report.Error(err) - continue - } - } - - // Create Cloudwatch Events for RDS - events, err := m.createCloudWatchEvents(metricDataOutput, regionName, dbDetailsMap) - if err != nil { - m.Logger().Error(err.Error()) - report.Error(err) - continue - } - - for _, event := range events { - if len(event.MetricSetFields) != 0 { - if reported := report.Event(event); !reported { - m.Logger().Debug("Fetch interrupted, failed to emit event") - return nil - } - } - } - } - - return nil -} - -func (m *MetricSet) getDBInstancesPerRegion(svc rdsiface.ClientAPI) ([]string, map[string]DBDetails, error) { - describeInstanceInput := &rds.DescribeDBInstancesInput{} - req := svc.DescribeDBInstancesRequest(describeInstanceInput) - output, err := req.Send(context.TODO()) - if err != nil { - return nil, nil, errors.Wrap(err, "Error DescribeDBInstancesRequest") - } - - var dbInstanceIDs []string - dbDetailsMap := map[string]DBDetails{} - for _, dbInstance := range output.DBInstances { - dbDetails := DBDetails{} - if dbInstance.DBInstanceIdentifier != nil { - dbDetails.dbIdentifier = *dbInstance.DBInstanceIdentifier - dbInstanceIDs = append(dbInstanceIDs, *dbInstance.DBInstanceIdentifier) - } - - if dbInstance.DBInstanceArn != nil { - dbDetails.dbArn = *dbInstance.DBInstanceArn - } - - if dbInstance.DBInstanceClass != nil { - dbDetails.dbClass = *dbInstance.DBInstanceClass - } - - if dbInstance.DBInstanceClass != nil { - dbDetails.dbStatus = *dbInstance.DBInstanceStatus - } - - if dbInstance.AvailabilityZone != nil { - dbDetails.dbAvailabilityZone = *dbInstance.AvailabilityZone - } - - // Get tags for each RDS instance - listTagsInput := rds.ListTagsForResourceInput{ - ResourceName: dbInstance.DBInstanceArn, - } - reqListTags := svc.ListTagsForResourceRequest(&listTagsInput) - outputListTags, err := reqListTags.Send(context.TODO()) - if err != nil { - m.Logger().Warn("ListTagsForResourceRequest failed, rds:ListTagsForResource permission is required for getting tags.") - dbDetailsMap[*dbInstance.DBInstanceIdentifier] = dbDetails - return dbInstanceIDs, dbDetailsMap, nil - } - - if m.TagsFilter != nil { - // Check with each tag filter - // If tag filter doesn't exist in tagKeys/tagValues, - // then remove this dbInstance entry from dbDetailsMap. - if exists := aws.CheckTagFiltersExist(m.TagsFilter, outputListTags.TagList); !exists { - delete(dbDetailsMap, *dbInstance.DBInstanceIdentifier) - continue - } - } - - for _, tag := range outputListTags.TagList { - // By default, replace dot "." using underscore "_" for tag keys. - // Note: tag values are not dedotted. - dbDetails.tags = append(dbDetails.tags, - aws.Tag{ - Key: common.DeDot(*tag.Key), - Value: *tag.Value, - }) - } - dbDetailsMap[*dbInstance.DBInstanceIdentifier] = dbDetails - } - return dbInstanceIDs, dbDetailsMap, nil -} - -func constructMetricQueries(listMetricsOutput []cloudwatch.Metric, period time.Duration) []cloudwatch.MetricDataQuery { - var metricDataQueries []cloudwatch.MetricDataQuery - metricDataQueryEmpty := cloudwatch.MetricDataQuery{} - for i, listMetric := range listMetricsOutput { - metricDataQuery := createMetricDataQuery(listMetric, i, period) - if metricDataQuery == metricDataQueryEmpty { - continue - } - metricDataQueries = append(metricDataQueries, metricDataQuery) - } - return metricDataQueries -} - -func createMetricDataQuery(metric cloudwatch.Metric, index int, period time.Duration) cloudwatch.MetricDataQuery { - statistic := "Average" - periodInSeconds := int64(period.Seconds()) - id := metricsetName + strconv.Itoa(index) - metricDims := metric.Dimensions - - metricDataQuery := cloudwatch.MetricDataQuery{ - Id: &id, - MetricStat: &cloudwatch.MetricStat{ - Period: &periodInSeconds, - Stat: &statistic, - Metric: &metric, - }, - } - - label := constructLabel(metricDims, *metric.MetricName) - metricDataQuery.Label = &label - return metricDataQuery -} - -func constructLabel(metricDimensions []cloudwatch.Dimension, metricName string) string { - // label = metricName + dimensionKey1 + dimensionValue1 - // + dimensionKey2 + dimensionValue2 + ... - label := metricName - if len(metricDimensions) != 0 { - for _, dim := range metricDimensions { - label += " " - label += *dim.Name + " " + *dim.Value - } - } - return label -} - -func (m *MetricSet) createCloudWatchEvents(getMetricDataResults []cloudwatch.MetricDataResult, regionName string, dbInstanceMap map[string]DBDetails) (map[string]mb.Event, error) { - // Initialize events and metricSetFieldResults per dbInstance - events := map[string]mb.Event{} - metricSetFieldResults := map[string]map[string]interface{}{} - - // Find a timestamp for all metrics in output - timestamp := aws.FindTimestamp(getMetricDataResults) - if timestamp.IsZero() { - return nil, nil - } - - for _, output := range getMetricDataResults { - if len(output.Values) == 0 { - continue - } - exists, timestampIdx := aws.CheckTimestampInArray(timestamp, output.Timestamps) - if exists { - labels := strings.Split(*output.Label, " ") - // Collect dimension values from the labels and initialize events and metricSetFieldResults with dimValues - var dimValues string - for i := 1; i < len(labels); i += 2 { - dimValues = dimValues + labels[i+1] - } - - if _, ok := events[dimValues]; !ok { - events[dimValues] = aws.InitEvent(regionName, m.AccountName, m.AccountID, timestamp) - } - - if _, ok := metricSetFieldResults[dimValues]; !ok { - metricSetFieldResults[dimValues] = map[string]interface{}{} - } - - if len(output.Values) > timestampIdx && len(labels) > 0 { - if labels[metricNameIdx] == "CPUUtilization" { - metricSetFieldResults[dimValues][labels[metricNameIdx]] = fmt.Sprint(output.Values[timestampIdx] / 100) - } else { - metricSetFieldResults[dimValues][labels[metricNameIdx]] = fmt.Sprint(output.Values[timestampIdx]) - } - - for i := 1; i < len(labels); i += 2 { - if labels[i] == "DBInstanceIdentifier" { - dbIdentifier := labels[i+1] - if _, found := events[dbIdentifier]; found { - if _, found := dbInstanceMap[dbIdentifier]; !found { - delete(metricSetFieldResults, dimValues) - continue - } - events[dbIdentifier].RootFields.Put("cloud.availability_zone", dbInstanceMap[dbIdentifier].dbAvailabilityZone) - events[dbIdentifier].MetricSetFields.Put("db_instance.arn", dbInstanceMap[dbIdentifier].dbArn) - events[dbIdentifier].MetricSetFields.Put("db_instance.class", dbInstanceMap[dbIdentifier].dbClass) - events[dbIdentifier].MetricSetFields.Put("db_instance.identifier", dbInstanceMap[dbIdentifier].dbIdentifier) - events[dbIdentifier].MetricSetFields.Put("db_instance.status", dbInstanceMap[dbIdentifier].dbStatus) - - for _, tag := range dbInstanceMap[dbIdentifier].tags { - events[dbIdentifier].ModuleFields.Put("tags."+tag.Key, tag.Value) - } - } - } - metricSetFieldResults[dimValues][labels[i]] = fmt.Sprint(labels[(i + 1)]) - } - - // if tags_filter is given, then only return metrics with DBInstanceIdentifier as dimension - if m.TagsFilter != nil { - if len(labels) == 1 { - delete(events, dimValues) - delete(metricSetFieldResults, dimValues) - } - - for i := 1; i < len(labels); i += 2 { - if labels[i] != "DBInstanceIdentifier" && i == len(labels)-2 { - delete(events, dimValues) - delete(metricSetFieldResults, dimValues) - } - } - } - } - } - } - - for dimValues, metricSetFieldsPerInstance := range metricSetFieldResults { - resultMetricsetFields, err := aws.EventMapping(metricSetFieldsPerInstance, schemaMetricSetFields) - if err != nil { - return events, errors.Wrap(err, "Error trying to apply schema schemaMetricSetFields in AWS RDS metricbeat module") - } - - events[dimValues].MetricSetFields.Update(resultMetricsetFields) - } - - return events, nil -} diff --git a/x-pack/metricbeat/module/aws/rds/rds_integration_test.go b/x-pack/metricbeat/module/aws/rds/rds_integration_test.go index f19d5a7dd05..21bc7879b81 100644 --- a/x-pack/metricbeat/module/aws/rds/rds_integration_test.go +++ b/x-pack/metricbeat/module/aws/rds/rds_integration_test.go @@ -12,6 +12,7 @@ import ( "github.com/stretchr/testify/assert" + _ "github.com/elastic/beats/v7/libbeat/processors/actions" mbtest "github.com/elastic/beats/v7/metricbeat/mb/testing" "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/mtest" ) @@ -32,8 +33,6 @@ func TestFetch(t *testing.T) { func TestData(t *testing.T) { config := mtest.GetConfigForTest(t, "rds", "60s") - metricSet := mbtest.NewReportingMetricSetV2Error(t, config) - if err := mbtest.WriteEventsReporterV2Error(metricSet, t, "/"); err != nil { - t.Fatal("write", err) - } + metricSet := mbtest.NewFetcher(t, config) + metricSet.WriteEvents(t, "/") } diff --git a/x-pack/metricbeat/module/aws/rds/rds_test.go b/x-pack/metricbeat/module/aws/rds/rds_test.go index 5537ecd430b..1a7b16063d7 100644 --- a/x-pack/metricbeat/module/aws/rds/rds_test.go +++ b/x-pack/metricbeat/module/aws/rds/rds_test.go @@ -2,278 +2,20 @@ // or more contributor license agreements. Licensed under the Elastic License; // you may not use this file except in compliance with the Elastic License. -// +build !integration - package rds import ( - "net/http" - "testing" - "time" - - awssdk "github.com/aws/aws-sdk-go-v2/aws" - "github.com/aws/aws-sdk-go-v2/service/cloudwatch" - "github.com/aws/aws-sdk-go-v2/service/rds" - "github.com/aws/aws-sdk-go-v2/service/rds/rdsiface" - "github.com/stretchr/testify/assert" + "os" - "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws" -) - -// MockRDSClient struct is used for unit tests. -type MockRDSClient struct { - rdsiface.ClientAPI -} + "github.com/elastic/beats/v7/metricbeat/mb" -var ( - metricName = "Queries" - namespace = "AWS/RDS" - period = 60 * time.Second - index = 0 - dimName1 = "DatabaseClass" - dbInstanceClass = "db.r5.large" - dimName2 = "Role" - dimValue2 = "READER" - dbInstanceArn = "arn:aws:rds:us-east-2:627959692251:db:test1" - availabilityZone = "us-east-1a" - dbInstanceIdentifier = "test1" - dbInstanceStatus = "available" + // Register input module and metricset + _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws" + _ "github.com/elastic/beats/v7/x-pack/metricbeat/module/aws/cloudwatch" ) -func TestCreateMetricDataQuery(t *testing.T) { - metric := cloudwatch.Metric{ - MetricName: &metricName, - Namespace: &namespace, - } - - metricDataQuery := createMetricDataQuery(metric, index, period) - assert.Equal(t, "Queries", *metricDataQuery.Label) - assert.Equal(t, "Average", *metricDataQuery.MetricStat.Stat) - assert.Equal(t, metricName, *metricDataQuery.MetricStat.Metric.MetricName) - assert.Equal(t, namespace, *metricDataQuery.MetricStat.Metric.Namespace) - assert.Equal(t, int64(60), *metricDataQuery.MetricStat.Period) -} - -func (m *MockRDSClient) DescribeDBInstancesRequest(input *rds.DescribeDBInstancesInput) rds.DescribeDBInstancesRequest { - httpReq, _ := http.NewRequest("", "", nil) - return rds.DescribeDBInstancesRequest{ - Request: &awssdk.Request{ - Data: &rds.DescribeDBInstancesOutput{ - DBInstances: []rds.DBInstance{ - { - AvailabilityZone: &availabilityZone, - DBInstanceArn: &dbInstanceArn, - DBInstanceClass: &dbInstanceClass, - DBInstanceIdentifier: &dbInstanceIdentifier, - DBInstanceStatus: &dbInstanceStatus, - }, - }, - }, - HTTPRequest: httpReq, - }, - } -} - -func (m *MockRDSClient) ListTagsForResourceRequest(input *rds.ListTagsForResourceInput) rds.ListTagsForResourceRequest { - httpReq, _ := http.NewRequest("", "", nil) - return rds.ListTagsForResourceRequest{ - Request: &awssdk.Request{ - Data: &rds.ListTagsForResourceOutput{ - TagList: []rds.Tag{ - {Key: awssdk.String("dept.name"), Value: awssdk.String("eng.software")}, - {Key: awssdk.String("created-by"), Value: awssdk.String("foo")}, - }, - }, - HTTPRequest: httpReq, - }, - } -} - -func TestConstructLabel(t *testing.T) { - cases := []struct { - dimensions []cloudwatch.Dimension - expectedLabel string - }{ - { - []cloudwatch.Dimension{}, - "Queries", - }, - { - []cloudwatch.Dimension{ - { - Name: &dimName1, - Value: &dbInstanceClass, - }, - }, - "Queries DatabaseClass db.r5.large", - }, - { - []cloudwatch.Dimension{ - { - Name: &dimName1, - Value: &dbInstanceClass, - }, - { - Name: &dimName2, - Value: &dimValue2, - }, - }, - "Queries DatabaseClass db.r5.large Role READER", - }, - } - for _, c := range cases { - assert.Equal(t, c.expectedLabel, constructLabel(c.dimensions, metricName)) - } -} - -func TestGetDBInstancesPerRegion(t *testing.T) { - mockSvc := &MockRDSClient{} - metricSet := MetricSet{ - &aws.MetricSet{}, - } - dbInstanceIDs, dbDetailsMap, err := metricSet.getDBInstancesPerRegion(mockSvc) - if err != nil { - t.FailNow() - } - - assert.Equal(t, 1, len(dbInstanceIDs)) - assert.Equal(t, 1, len(dbDetailsMap)) - - dbInstanceMap := DBDetails{ - dbArn: dbInstanceArn, - dbClass: dbInstanceClass, - dbAvailabilityZone: availabilityZone, - dbIdentifier: dbInstanceIdentifier, - dbStatus: dbInstanceStatus, - tags: []aws.Tag{ - {Key: "dept_name", Value: "eng.software"}, - {Key: "created-by", Value: "foo"}, - }, - } - assert.Equal(t, dbInstanceMap, dbDetailsMap[dbInstanceIDs[0]]) -} - -func TestGetDBInstancesPerRegionWithTagsFilter(t *testing.T) { - mockSvc := &MockRDSClient{} - metricSet := MetricSet{ - &aws.MetricSet{ - TagsFilter: []aws.Tag{ - {Key: "created-by", Value: "foo"}, - }, - }, - } - dbInstanceIDs, dbDetailsMap, err := metricSet.getDBInstancesPerRegion(mockSvc) - if err != nil { - t.FailNow() - } - - assert.Equal(t, 1, len(dbInstanceIDs)) - assert.Equal(t, 1, len(dbDetailsMap)) - - dbInstanceMap := DBDetails{ - dbArn: dbInstanceArn, - dbClass: dbInstanceClass, - dbAvailabilityZone: availabilityZone, - dbIdentifier: dbInstanceIdentifier, - dbStatus: dbInstanceStatus, - tags: []aws.Tag{ - {Key: "dept_name", Value: "eng.software"}, - {Key: "created-by", Value: "foo"}, - }, - } - assert.Equal(t, dbInstanceMap, dbDetailsMap[dbInstanceIDs[0]]) -} - -func TestGetDBInstancesPerRegionWithDotInTag(t *testing.T) { - mockSvc := &MockRDSClient{} - metricSet := MetricSet{ - &aws.MetricSet{ - TagsFilter: []aws.Tag{ - {Key: "dept.name", Value: "eng.software"}, - }, - }, - } - dbInstanceIDs, dbDetailsMap, err := metricSet.getDBInstancesPerRegion(mockSvc) - if err != nil { - t.FailNow() - } - - assert.Equal(t, 1, len(dbInstanceIDs)) - assert.Equal(t, 1, len(dbDetailsMap)) - - dbInstanceMap := DBDetails{ - dbArn: dbInstanceArn, - dbClass: dbInstanceClass, - dbAvailabilityZone: availabilityZone, - dbIdentifier: dbInstanceIdentifier, - dbStatus: dbInstanceStatus, - tags: []aws.Tag{ - {Key: "dept_name", Value: "eng.software"}, - {Key: "created-by", Value: "foo"}, - }, - } - assert.Equal(t, dbInstanceMap, dbDetailsMap[dbInstanceIDs[0]]) -} - -func TestGetDBInstancesPerRegionWithNoMatchingTagsFilter(t *testing.T) { - mockSvc := &MockRDSClient{} - metricSet := MetricSet{ - &aws.MetricSet{ - TagsFilter: []aws.Tag{ - {Key: "dept.name", Value: "accounting"}, - }, - }, - } - dbInstanceIDs, dbDetailsMap, err := metricSet.getDBInstancesPerRegion(mockSvc) - if err != nil { - t.FailNow() - } - - assert.Equal(t, 1, len(dbInstanceIDs)) - assert.Equal(t, 0, len(dbDetailsMap)) -} - -func TestConstructMetricQueries(t *testing.T) { - dim1 := cloudwatch.Dimension{ - Name: &dimName1, - Value: &dbInstanceClass, - } - - dim2 := cloudwatch.Dimension{ - Name: &dimName2, - Value: &dimValue2, - } - - listMetric1 := cloudwatch.Metric{ - Dimensions: []cloudwatch.Dimension{dim1}, - MetricName: &metricName, - Namespace: &namespace, - } - - listMetric2 := cloudwatch.Metric{ - Dimensions: []cloudwatch.Dimension{dim2}, - MetricName: &metricName, - Namespace: &namespace, - } - - listMetricsOutput := []cloudwatch.Metric{listMetric1, listMetric2} - metricDataQueries := constructMetricQueries(listMetricsOutput, period) - assert.Equal(t, 2, len(metricDataQueries)) - - assert.Equal(t, "rds0", *metricDataQueries[0].Id) - assert.Equal(t, "Queries DatabaseClass db.r5.large", *metricDataQueries[0].Label) - assert.Equal(t, "Queries", *metricDataQueries[0].MetricStat.Metric.MetricName) - assert.Equal(t, "AWS/RDS", *metricDataQueries[0].MetricStat.Metric.Namespace) - assert.Equal(t, []cloudwatch.Dimension{dim1}, metricDataQueries[0].MetricStat.Metric.Dimensions) - assert.Equal(t, int64(60), *metricDataQueries[0].MetricStat.Period) - assert.Equal(t, "Average", *metricDataQueries[0].MetricStat.Stat) - - assert.Equal(t, "rds1", *metricDataQueries[1].Id) - assert.Equal(t, "Queries Role READER", *metricDataQueries[1].Label) - assert.Equal(t, "Queries", *metricDataQueries[1].MetricStat.Metric.MetricName) - assert.Equal(t, "AWS/RDS", *metricDataQueries[1].MetricStat.Metric.Namespace) - assert.Equal(t, []cloudwatch.Dimension{dim2}, metricDataQueries[1].MetricStat.Metric.Dimensions) - assert.Equal(t, int64(60), *metricDataQueries[1].MetricStat.Period) - assert.Equal(t, "Average", *metricDataQueries[1].MetricStat.Stat) - +func init() { + // To be moved to some kind of helper + os.Setenv("BEAT_STRICT_PERMS", "false") + mb.Registry.SetSecondarySource(mb.NewLightModulesSource("../../../module")) } From 07fa7f699487a2afc13bf0474c83325ee7c77e91 Mon Sep 17 00:00:00 2001 From: Adrian Serrano Date: Mon, 7 Jun 2021 15:39:56 +0200 Subject: [PATCH 3/7] o365: Support non-array Parameters and ExtendedProperties fields (#26164) These fields are documented as being an array of Name-value pairs. However, in some cases they appear as a string field, leading to mapping errors. This patch will perform the expected name-value conversion by creating a new key, "_raw" with the original field value, when the fields are not arrays. --- CHANGELOG.next.asciidoc | 1 + .../module/o365/audit/config/pipeline.js | 6 +- .../module/o365/audit/test/str-params.log | 2 + .../audit/test/str-params.log-expected.json | 131 ++++++++++++++++++ 4 files changed, 139 insertions(+), 1 deletion(-) create mode 100644 x-pack/filebeat/module/o365/audit/test/str-params.log create mode 100644 x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 40506f5bbbf..8f4be40e0b7 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -382,6 +382,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix `fortinet.firewall.addr` when its a string, not an IP address. {issue}25585[25585] {pull}25608[25608] - Fix incorrect field name appending to `related.hash` in `threatintel.abusechmalware` ingest pipeline. {issue}25151[25151] {pull}25674[25674] - Fix `kibana.log` pipeline when `event.duration` calculation becomes a Long. {issue}24556[24556] {pull}25675[25675] +- o365: Avoid mapping exception for `Parameters` and `ExtendedProperties` fields of string type. {pull}26164[26164] *Heartbeat* diff --git a/x-pack/filebeat/module/o365/audit/config/pipeline.js b/x-pack/filebeat/module/o365/audit/config/pipeline.js index dd1fe588e9e..9fadd46eb31 100644 --- a/x-pack/filebeat/module/o365/audit/config/pipeline.js +++ b/x-pack/filebeat/module/o365/audit/config/pipeline.js @@ -108,7 +108,11 @@ function makeObjFromNameValuePairArray(options) { return function(evt) { var src = evt.Get(options.from); var dict = {}; - if (src == null || !(src instanceof Array)) return; + if (src == null) return; + if (!(src instanceof Array)) { + evt.Put(options.to, {"_raw": src} ); + return; + } for (var i=0; i < src.length; i++) { var name, value; if (src[i] == null diff --git a/x-pack/filebeat/module/o365/audit/test/str-params.log b/x-pack/filebeat/module/o365/audit/test/str-params.log new file mode 100644 index 00000000000..d5856330b9b --- /dev/null +++ b/x-pack/filebeat/module/o365/audit/test/str-params.log @@ -0,0 +1,2 @@ +{"OriginatingServer": "HE1PR0102MB3228 (15.20.2707.017)", "ClientAppId": "", "OrganizationName": "testsiem.onmicrosoft.com", "ObjectId": "EURPR01A002.prod.outlook.com/Microsoft Exchange Hosted Organizations/testsiem.onmicrosoft.com/DiscoverySearchMailbox{D919BA05-46A6-415f-80AD-7E09334BB852}", "Parameters": "-StartReceivedDate \"4/25/2021 7:00:00 AM\" -EndReceivedDate \"5/27/2021 7:00:00 AM\" -StartExpiresDate \"5/26/2021 7:00:00 AM\" -EndExpiresDate \"6/26/2021 7:00:00 AM\" -PageSize \"100\" -Page \"1\" -MyItems \"True\" -QuarantineTypes (\"Bulk\",\"Spam\",\"Phish\")", "Workload": "Exchange", "OrganizationId": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", "CreationTime": "2020-02-07T20:49:49", "AppId": "", "UserId": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", "UserType": 3, "Version": 1, "ResultStatus": "True", "ExternalAccess": true, "UserKey": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", "Operation": "Set-Mailbox", "Id": "1c7412a6-858d-49ff-3f93-08d7ac0f45bf", "RecordType": 1} +{"CreationTime":"2021-02-05T09:06:07","Id":"550ed0e2-27da-4cbc-9fb8-46add4018800","Operation":"UserLoggedIn","OrganizationId":"48622b8f-44d3-420c-b4a2-510c8165767e","RecordType":15,"ResultStatus":"Success","UserKey":"21119711-1517-43d4-8138-b537dafad016","UserType":0,"Version":1,"Workload":"AzureActiveDirectory","ClientIP":"79.159.11.115","ObjectId":"Unknown","UserId":"root@testsiem4.onmicrosoft.com","AzureActiveDirectoryEventType":1,"ExtendedProperties": "-Name \"foo\" -Description \"\" -HoldNames () -PublicFolderLocation () -ExchangeLocationExclusion () -IncludeUserAppContent \"True\" -SharePointLocationExclusion () -Force \"True\" -Language \"\" -SharePointLocation () -ExchangeLocation (\"All\") -ContentMatchQuery \"(c:c)(senderauthor=abc@foo.com)\"","ModifiedProperties":[],"Actor":[{"ID":"21119711-1517-43d4-8138-b537dafad016","Type":0},{"ID":"root@testsiem4.onmicrosoft.com","Type":5}],"ActorContextId":"48622b8f-44d3-420c-b4a2-510c8165767e","ActorIpAddress":"79.159.11.115","InterSystemsId":"df4c6d6c-4551-4f2d-8766-03700dfccb47","IntraSystemId":"550ed0e2-27da-4cbc-9fb8-46add4018800","SupportTicketId":"","Target":[{"ID":"Unknown","Type":0}],"TargetContextId":"48622b8f-44d3-420c-b4a2-510c8165767e","ApplicationId":"89bee1f7-5e6e-4d8a-9f3d-ecd601259da7","ErrorNumber":"0"} diff --git a/x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json b/x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json new file mode 100644 index 00000000000..764d9283acf --- /dev/null +++ b/x-pack/filebeat/module/o365/audit/test/str-params.log-expected.json @@ -0,0 +1,131 @@ +[ + { + "@timestamp": "2020-02-07T20:49:49.000Z", + "event.action": "Set-Mailbox", + "event.category": "web", + "event.code": "ExchangeAdmin", + "event.dataset": "o365.audit", + "event.id": "1c7412a6-858d-49ff-3f93-08d7ac0f45bf", + "event.kind": "event", + "event.module": "o365", + "event.outcome": "success", + "event.provider": "Exchange", + "event.type": "info", + "fileset.name": "audit", + "host.id": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", + "host.name": "testsiem.onmicrosoft.com", + "input.type": "log", + "log.offset": 0, + "o365.audit.AppId": "", + "o365.audit.ClientAppId": "", + "o365.audit.CreationTime": "2020-02-07T20:49:49", + "o365.audit.ExternalAccess": true, + "o365.audit.Id": "1c7412a6-858d-49ff-3f93-08d7ac0f45bf", + "o365.audit.ObjectId": "EURPR01A002.prod.outlook.com/Microsoft Exchange Hosted Organizations/testsiem.onmicrosoft.com/DiscoverySearchMailbox{D919BA05-46A6-415f-80AD-7E09334BB852}", + "o365.audit.Operation": "Set-Mailbox", + "o365.audit.OrganizationId": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", + "o365.audit.OrganizationName": "testsiem.onmicrosoft.com", + "o365.audit.OriginatingServer": "HE1PR0102MB3228 (15.20.2707.017)", + "o365.audit.Parameters._raw": "-StartReceivedDate \"4/25/2021 7:00:00 AM\" -EndReceivedDate \"5/27/2021 7:00:00 AM\" -StartExpiresDate \"5/26/2021 7:00:00 AM\" -EndExpiresDate \"6/26/2021 7:00:00 AM\" -PageSize \"100\" -Page \"1\" -MyItems \"True\" -QuarantineTypes (\"Bulk\",\"Spam\",\"Phish\")", + "o365.audit.RecordType": 1, + "o365.audit.ResultStatus": "True", + "o365.audit.UserId": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", + "o365.audit.UserKey": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)", + "o365.audit.UserType": 3, + "o365.audit.Version": 1, + "o365.audit.Workload": "Exchange", + "organization.id": "b86ab9d4-fcf1-4b11-8a06-7a8f91b47fbd", + "organization.name": "testsiem.onmicrosoft.com", + "server.address": "HE1PR0102MB3228 (15.20.2707.017)", + "service.type": "o365", + "tags": [ + "forwarded" + ], + "user.id": "NT AUTHORITY\\SYSTEM (Microsoft.Exchange.ServiceHost)" + }, + { + "@timestamp": "2021-02-05T09:06:07.000Z", + "client.address": "79.159.11.115", + "client.ip": "79.159.11.115", + "event.action": "UserLoggedIn", + "event.category": "authentication", + "event.code": "AzureActiveDirectoryStsLogon", + "event.dataset": "o365.audit", + "event.id": "550ed0e2-27da-4cbc-9fb8-46add4018800", + "event.kind": "event", + "event.module": "o365", + "event.outcome": "success", + "event.provider": "AzureActiveDirectory", + "event.type": [ + "authentication_success", + "start" + ], + "fileset.name": "audit", + "host.id": "48622b8f-44d3-420c-b4a2-510c8165767e", + "host.name": "testsiem4.onmicrosoft.com", + "input.type": "log", + "log.offset": 1014, + "network.type": "ipv4", + "o365.audit.Actor": [ + { + "ID": "21119711-1517-43d4-8138-b537dafad016", + "Type": 0 + }, + { + "ID": "root@testsiem4.onmicrosoft.com", + "Type": 5 + } + ], + "o365.audit.ActorContextId": "48622b8f-44d3-420c-b4a2-510c8165767e", + "o365.audit.ActorIpAddress": "79.159.11.115", + "o365.audit.ApplicationId": "89bee1f7-5e6e-4d8a-9f3d-ecd601259da7", + "o365.audit.AzureActiveDirectoryEventType": 1, + "o365.audit.ClientIP": "79.159.11.115", + "o365.audit.CreationTime": "2021-02-05T09:06:07", + "o365.audit.ErrorNumber": "0", + "o365.audit.ExtendedProperties._raw": "-Name \"foo\" -Description \"\" -HoldNames () -PublicFolderLocation () -ExchangeLocationExclusion () -IncludeUserAppContent \"True\" -SharePointLocationExclusion () -Force \"True\" -Language \"\" -SharePointLocation () -ExchangeLocation (\"All\") -ContentMatchQuery \"(c:c)(senderauthor=abc@foo.com)\"", + "o365.audit.Id": "550ed0e2-27da-4cbc-9fb8-46add4018800", + "o365.audit.InterSystemsId": "df4c6d6c-4551-4f2d-8766-03700dfccb47", + "o365.audit.IntraSystemId": "550ed0e2-27da-4cbc-9fb8-46add4018800", + "o365.audit.ObjectId": "Unknown", + "o365.audit.Operation": "UserLoggedIn", + "o365.audit.OrganizationId": "48622b8f-44d3-420c-b4a2-510c8165767e", + "o365.audit.RecordType": 15, + "o365.audit.ResultStatus": "Success", + "o365.audit.SupportTicketId": "", + "o365.audit.Target": [ + { + "ID": "Unknown", + "Type": 0 + } + ], + "o365.audit.TargetContextId": "48622b8f-44d3-420c-b4a2-510c8165767e", + "o365.audit.UserId": "root@testsiem4.onmicrosoft.com", + "o365.audit.UserKey": "21119711-1517-43d4-8138-b537dafad016", + "o365.audit.UserType": 0, + "o365.audit.Version": 1, + "o365.audit.Workload": "AzureActiveDirectory", + "organization.id": "48622b8f-44d3-420c-b4a2-510c8165767e", + "related.ip": "79.159.11.115", + "related.user": "root", + "service.type": "o365", + "source.as.number": 3352, + "source.as.organization.name": "Telefonica De Espana", + "source.geo.city_name": "Barcelona", + "source.geo.continent_name": "Europe", + "source.geo.country_iso_code": "ES", + "source.geo.country_name": "Spain", + "source.geo.location.lat": 41.3891, + "source.geo.location.lon": 2.1611, + "source.geo.region_iso_code": "ES-B", + "source.geo.region_name": "Barcelona", + "source.ip": "79.159.11.115", + "tags": [ + "forwarded" + ], + "user.domain": "testsiem4.onmicrosoft.com", + "user.email": "root@testsiem4.onmicrosoft.com", + "user.id": "root@testsiem4.onmicrosoft.com", + "user.name": "root" + } +] \ No newline at end of file From 3b50a28dff85caf6b5e0ecc77a6b24f7e681628a Mon Sep 17 00:00:00 2001 From: Adrian Serrano Date: Mon, 7 Jun 2021 15:41:31 +0200 Subject: [PATCH 4/7] auditd: Fix kernel deadlock after ENOBUFS (#26032) This fixes a deadlock when the netlink channel is congested (initialization fails with "no buffer space available" / errno=ENOBUFS). Closes #26031 --- CHANGELOG.next.asciidoc | 1 + auditbeat/module/auditd/audit_linux.go | 50 +++++++++++++++++++++++--- 2 files changed, 46 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 8f4be40e0b7..de570f85c4e 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -259,6 +259,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - system/socket: Fixed start failure when run under config reloader. {issue}20851[20851] {pull}21693[21693] - system/socket: Having some CPUs unavailable to Auditbeat could cause startup errors or event loss. {pull}22827[22827] - Note incompatibility of system/socket on ARM. {pull}23381[23381] +- auditd: Fix kernel deadlock when netlink congestion causes "no buffer space available" errors. {issue}26031[26031] {pull}26032[26032] *Filebeat* diff --git a/auditbeat/module/auditd/audit_linux.go b/auditbeat/module/auditd/audit_linux.go index 1cd9133a917..7324e423986 100644 --- a/auditbeat/module/auditd/audit_linux.go +++ b/auditbeat/module/auditd/audit_linux.go @@ -51,6 +51,8 @@ const ( lostEventsUpdateInterval = time.Second * 15 maxDefaultStreamBufferConsumers = 4 + + setPIDMaxRetries = 5 ) type backpressureStrategy uint8 @@ -137,10 +139,32 @@ func newAuditClient(c *Config, log *logp.Logger) (*libaudit.AuditClient, error) return libaudit.NewAuditClient(nil) } +func closeAuditClient(client *libaudit.AuditClient) error { + discard := func(bytes []byte) ([]syscall.NetlinkMessage, error) { + return nil, nil + } + // Drain the netlink channel in parallel to Close() to prevent a deadlock. + // This goroutine will terminate once receive from netlink errors (EBADF, + // EBADFD, or any other error). This happens because the fd is closed. + go func() { + for { + _, err := client.Netlink.Receive(true, discard) + switch err { + case nil, syscall.EINTR: + case syscall.EAGAIN: + time.Sleep(50 * time.Millisecond) + default: + return + } + } + }() + return client.Close() +} + // Run initializes the audit client and receives audit messages from the // kernel until the reporter's done channel is closed. func (ms *MetricSet) Run(reporter mb.PushReporterV2) { - defer ms.client.Close() + defer closeAuditClient(ms.client) if err := ms.addRules(reporter); err != nil { reporter.Error(err) @@ -164,7 +188,7 @@ func (ms *MetricSet) Run(reporter mb.PushReporterV2) { go func() { defer func() { // Close the most recently allocated "client" instance. if client != nil { - client.Close() + closeAuditClient(client) } }() timer := time.NewTicker(lostEventsUpdateInterval) @@ -178,7 +202,7 @@ func (ms *MetricSet) Run(reporter mb.PushReporterV2) { ms.updateKernelLostMetric(status.Lost) } else { ms.log.Error("get status request failed:", err) - if err = client.Close(); err != nil { + if err = closeAuditClient(client); err != nil { ms.log.Errorw("Error closing audit monitoring client", "error", err) } client, err = libaudit.NewAuditClient(nil) @@ -233,7 +257,7 @@ func (ms *MetricSet) addRules(reporter mb.PushReporterV2) error { if err != nil { return errors.Wrap(err, "failed to create audit client for adding rules") } - defer client.Close() + defer closeAuditClient(client) // Don't attempt to change configuration if audit rules are locked (enabled == 2). // Will result in EPERM. @@ -350,10 +374,12 @@ func (ms *MetricSet) initClient() error { return errors.Wrap(err, "failed to enable auditing in the kernel") } } + if err := ms.client.WaitForPendingACKs(); err != nil { return errors.Wrap(err, "failed to wait for ACKs") } - if err := ms.client.SetPID(libaudit.WaitForReply); err != nil { + + if err := ms.setPID(setPIDMaxRetries); err != nil { if errno, ok := err.(syscall.Errno); ok && errno == syscall.EEXIST && status.PID != 0 { return fmt.Errorf("failed to set audit PID. An audit process is already running (PID %d)", status.PID) } @@ -362,6 +388,20 @@ func (ms *MetricSet) initClient() error { return nil } +func (ms *MetricSet) setPID(retries int) (err error) { + if err = ms.client.SetPID(libaudit.WaitForReply); err == nil || errors.Cause(err) != syscall.ENOBUFS || retries == 0 { + return err + } + // At this point the netlink channel is congested (ENOBUFS). + // Drain and close the client, then retry with a new client. + closeAuditClient(ms.client) + if ms.client, err = newAuditClient(&ms.config, ms.log); err != nil { + return errors.Wrapf(err, "failed to recover from ENOBUFS") + } + ms.log.Info("Recovering from ENOBUFS ...") + return ms.setPID(retries - 1) +} + func (ms *MetricSet) updateKernelLostMetric(lost uint32) { if !ms.kernelLost.enabled { return From 8bbb26f437df9fdac6f8504fa03268137e04ba6d Mon Sep 17 00:00:00 2001 From: Adrian Serrano Date: Mon, 7 Jun 2021 16:10:04 +0200 Subject: [PATCH 5/7] http_endpoint: Allow receiving multiple documents on a single request (#25764) Updates Filebeat's http_endpoint to produce multiple documents from a single POST request. This extends the application/json format handling to accept arrays of objects, and adds support for the NDJSON format (application/x-ndjson). --- CHANGELOG.next.asciidoc | 1 + .../filebeat/input/http_endpoint/handler.go | 62 +++++++------ .../input/http_endpoint/handler_test.go | 93 +++++++++++++++++++ .../tests/system/test_http_endpoint.py | 62 ++++++++++++- 4 files changed, 187 insertions(+), 31 deletions(-) create mode 100644 x-pack/filebeat/input/http_endpoint/handler_test.go diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index de570f85c4e..a636265ece8 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -810,6 +810,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add fingerprint processor to generate fixed ids for `google_workspace` events. {pull}25841[25841] - Update PanOS module to parse HIP Match logs. {issue}24350[24350] {pull}25686[25686] - Enhance GCP module to populate orchestrator.* fields for GKE / K8S logs {pull}25368[25368] +- http_endpoint: Support multiple documents in a single request by POSTing an array or NDJSON format. {pull}25764[25764] *Heartbeat* diff --git a/x-pack/filebeat/input/http_endpoint/handler.go b/x-pack/filebeat/input/http_endpoint/handler.go index f821301fe79..6d1c0374dc3 100644 --- a/x-pack/filebeat/input/http_endpoint/handler.go +++ b/x-pack/filebeat/input/http_endpoint/handler.go @@ -5,15 +5,14 @@ package http_endpoint import ( - "bytes" "encoding/json" - "errors" "fmt" "io" - "io/ioutil" "net/http" "time" + "github.com/pkg/errors" + stateless "github.com/elastic/beats/v7/filebeat/input/v2/input-stateless" "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common" @@ -36,19 +35,20 @@ var ( // Triggers if middleware validation returns successful func (h *httpHandler) apiResponse(w http.ResponseWriter, r *http.Request) { - obj, status, err := httpReadJsonObject(r.Body) + objs, status, err := httpReadJSON(r.Body) if err != nil { - w.Header().Add("Content-Type", "application/json") sendErrorResponse(w, status, err) return } - h.publishEvent(obj) - w.Header().Add("Content-Type", "application/json") + for _, obj := range objs { + h.publishEvent(obj) + } h.sendResponse(w, h.responseCode, h.responseBody) } func (h *httpHandler) sendResponse(w http.ResponseWriter, status int, message string) { + w.Header().Add("Content-Type", "application/json") w.WriteHeader(status) io.WriteString(w, message) } @@ -82,32 +82,34 @@ func sendErrorResponse(w http.ResponseWriter, status int, err error) { e.Encode(common.MapStr{"message": err.Error()}) } -func httpReadJsonObject(body io.Reader) (obj common.MapStr, status int, err error) { +func httpReadJSON(body io.Reader) (objs []common.MapStr, status int, err error) { if body == http.NoBody { return nil, http.StatusNotAcceptable, errBodyEmpty } - contents, err := ioutil.ReadAll(body) - if err != nil { - return nil, http.StatusInternalServerError, fmt.Errorf("failed reading body: %w", err) - } - - if !isObject(contents) { - return nil, http.StatusBadRequest, errUnsupportedType - } - - obj = common.MapStr{} - if err := json.Unmarshal(contents, &obj); err != nil { - return nil, http.StatusBadRequest, fmt.Errorf("malformed JSON body: %w", err) - } - - return obj, 0, nil -} - -func isObject(b []byte) bool { - obj := bytes.TrimLeft(b, " \t\r\n") - if len(obj) > 0 && obj[0] == '{' { - return true + decoder := json.NewDecoder(body) + for idx := 0; ; idx++ { + var obj interface{} + if err := decoder.Decode(&obj); err != nil { + if err == io.EOF { + break + } + return nil, http.StatusBadRequest, errors.Wrapf(err, "malformed JSON object at stream position %d", idx) + } + switch v := obj.(type) { + case map[string]interface{}: + objs = append(objs, v) + case []interface{}: + for listIdx, listObj := range v { + asMap, ok := listObj.(map[string]interface{}) + if !ok { + return nil, http.StatusBadRequest, fmt.Errorf("%v at stream %d index %d", errUnsupportedType, idx, listIdx) + } + objs = append(objs, asMap) + } + default: + return nil, http.StatusBadRequest, errUnsupportedType + } } - return false + return objs, 0, nil } diff --git a/x-pack/filebeat/input/http_endpoint/handler_test.go b/x-pack/filebeat/input/http_endpoint/handler_test.go new file mode 100644 index 00000000000..ef1b36d2e73 --- /dev/null +++ b/x-pack/filebeat/input/http_endpoint/handler_test.go @@ -0,0 +1,93 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package http_endpoint + +import ( + "net/http" + "reflect" + "strings" + "testing" + + "github.com/elastic/beats/v7/libbeat/common" +) + +func Test_httpReadJSON(t *testing.T) { + tests := []struct { + name string + body string + wantObjs []common.MapStr + wantStatus int + wantErr bool + }{ + { + name: "single object", + body: `{"a": 42, "b": "c"}`, + wantObjs: []common.MapStr{{"a": float64(42), "b": "c"}}, + }, + { + name: "array accepted", + body: `[{"a":"b"},{"c":"d"}]`, + wantObjs: []common.MapStr{{"a": "b"}, {"c": "d"}}, + }, + { + name: "not an object not accepted", + body: `42`, + wantStatus: http.StatusBadRequest, + wantErr: true, + }, + { + name: "not an object mixed", + body: "[{\"a\":1},\n42,\n{\"a\":2}]", + wantStatus: http.StatusBadRequest, + wantErr: true, + }, + { + name: "sequence of objects accepted (CRLF)", + body: "{\"a\":1}\r\n{\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "sequence of objects accepted (LF)", + body: "{\"a\":1}\n{\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "sequence of objects accepted (SP)", + body: "{\"a\":1} {\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "sequence of objects accepted (no separator)", + body: "{\"a\":1}{\"a\":2}", + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}}, + }, + { + name: "not an object in sequence", + body: "{\"a\":1}\n42\n{\"a\":2}", + wantStatus: http.StatusBadRequest, + wantErr: true, + }, + { + name: "array of objects in stream", + body: `{"a":1} [{"a":2},{"a":3}] {"a":4}`, + wantObjs: []common.MapStr{{"a": float64(1)}, {"a": float64(2)}, {"a": float64(3)}, {"a": float64(4)}}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotObjs, gotStatus, err := httpReadJSON(strings.NewReader(tt.body)) + if (err != nil) != tt.wantErr { + t.Errorf("httpReadJSON() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(gotObjs, tt.wantObjs) { + t.Errorf("httpReadJSON() gotObjs = %v, want %v", gotObjs, tt.wantObjs) + } + if gotStatus != tt.wantStatus { + t.Errorf("httpReadJSON() gotStatus = %v, want %v", gotStatus, tt.wantStatus) + } + }) + } +} diff --git a/x-pack/filebeat/tests/system/test_http_endpoint.py b/x-pack/filebeat/tests/system/test_http_endpoint.py index 7be145945e6..688b46852e2 100644 --- a/x-pack/filebeat/tests/system/test_http_endpoint.py +++ b/x-pack/filebeat/tests/system/test_http_endpoint.py @@ -84,6 +84,66 @@ def test_http_endpoint_request(self): assert output[0]["input.type"] == "http_endpoint" assert output[0]["json.{}".format(self.prefix)] == message + def test_http_endpoint_request_multiple_documents(self): + """ + Test http_endpoint input with multiple documents on a single HTTP request. + """ + self.get_config() + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + + N = 10 + message = "somerandommessage_{}" + payload = [{self.prefix: message.format(i)} for i in range(N)] + headers = {"Content-Type": "application/json", "Accept": "application/json"} + r = requests.post(self.url, headers=headers, data=json.dumps(payload)) + + self.wait_until(lambda: self.output_count(lambda x: x == N)) + filebeat.check_kill_and_wait() + + output = self.read_output() + + print("response:", r.status_code, r.text) + + assert r.text == '{"message": "success"}' + + assert len(output) == N + for i in range(N): + assert output[i]["input.type"] == "http_endpoint" + assert output[i]["json.{}".format(self.prefix)] == message.format(i) + + def test_http_endpoint_request_ndjson(self): + """ + Test http_endpoint input with multiple documents on a single HTTP request (NDJSON). + """ + + options = """ + content_type: application/x-ndjson +""" + self.get_config(options) + filebeat = self.start_beat() + self.wait_until(lambda: self.log_contains("Starting HTTP server on {}:{}".format(self.host, self.port))) + + N = 10 + message = "somerandommessage_{}" + payload = "\n".join([json.dumps({self.prefix: message.format(i)}) for i in range(N)]) + headers = {"Content-Type": "application/x-ndjson", "Accept": "application/json"} + r = requests.post(self.url, headers=headers, data=payload) + + self.wait_until(lambda: self.output_count(lambda x: x == N)) + filebeat.check_kill_and_wait() + + output = self.read_output() + + print("response:", r.status_code, r.text) + + assert r.text == '{"message": "success"}' + + assert len(output) == N + for i in range(N): + assert output[i]["input.type"] == "http_endpoint" + assert output[i]["json.{}".format(self.prefix)] == message.format(i) + def test_http_endpoint_wrong_content_header(self): """ Test http_endpoint input with wrong content header. @@ -283,7 +343,7 @@ def test_http_endpoint_malformed_json(self): print("response:", r.status_code, r.text) assert r.status_code == 400 - self.assertRegex(r.json()['message'], 'malformed JSON body') + self.assertRegex(r.json()['message'], 'malformed JSON') def test_http_endpoint_get_request(self): """ From 447bac937949bce27cee3a5c9ff10669de16555f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?No=C3=A9mi=20V=C3=A1nyi?= Date: Mon, 7 Jun 2021 18:00:26 +0200 Subject: [PATCH 6/7] Include date separator in the filename prefix of `dateRotator` to make sure nothing gets purged accidentally (#26176) ## What does this PR do? This PR changes the log file prefix when using date rotation in Beats. Previously the `-` was not included, so in the list of rotated files every file that started with the configured file prefix were included. ## Why is it important? If the binary is under the same path as the value configured in `logging.files.path` and `logging.files.name`, when the number of rotated log files gets bigger than the one configured in `loggin.files.keepfiles`, the binary is purged on rotation. The workaround is to put the log files in a separate folder. --- CHANGELOG.next.asciidoc | 1 + libbeat/common/file/rotator.go | 8 ++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index a636265ece8..b516e7b8792 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -238,6 +238,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Fix 'make setup' instructions for a new beat {pull}24944[24944] - Fix out of date FreeBSD vagrantbox. {pull}25652[25652] - Fix handling of `file_selectors` in aws-s3 input. {pull}25792[25792] +- Include date separator in the filename prefix of `dateRotator` to make sure nothing gets purged accidentally {pull}26176[26176] *Auditbeat* diff --git a/libbeat/common/file/rotator.go b/libbeat/common/file/rotator.go index d6c35d6e102..633f94232ef 100644 --- a/libbeat/common/file/rotator.go +++ b/libbeat/common/file/rotator.go @@ -435,11 +435,11 @@ func newRotater(log Logger, s SuffixType, filename string, maxBackups uint, inte func newDateRotater(log Logger, filename string) rotater { d := &dateRotator{ log: log, - filenamePrefix: filename, + filenamePrefix: filename + "-", format: "20060102150405", } - d.currentFilename = d.filenamePrefix + "-" + time.Now().Format(d.format) + d.currentFilename = d.filenamePrefix + time.Now().Format(d.format) files, err := filepath.Glob(d.filenamePrefix + "*") if err != nil { return d @@ -467,7 +467,7 @@ func (d *dateRotator) Rotate(reason rotateReason, rotateTime time.Time) error { d.log.Debugw("Rotating file", "filename", d.currentFilename, "reason", reason) } - d.currentFilename = d.filenamePrefix + "-" + rotateTime.Format(d.format) + d.currentFilename = d.filenamePrefix + rotateTime.Format(d.format) return nil } @@ -493,7 +493,7 @@ func (d *dateRotator) SortModTimeLogs(strings []string) { } func (d *dateRotator) OrderLog(filename string) time.Time { - ts, err := time.Parse(d.format, filepath.Base(filename)) + ts, err := time.Parse(d.filenamePrefix+d.format, filepath.Base(filename)) if err != nil { return time.Time{} } From cb085d0f974d0b8e39cf8e35508be6d83354211b Mon Sep 17 00:00:00 2001 From: Vignesh Shanmugam Date: Mon, 7 Jun 2021 13:10:08 -0700 Subject: [PATCH 7/7] [Heartbeat]: add mappings for performance metrics (#26140) * [Heartbeat]: add mappings for performance metrics * build new mappings * address review comments * update fields Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> --- heartbeat/_meta/fields.common.yml | 58 +++++++++++++++++-- heartbeat/docs/fields.asciidoc | 92 ++++++++++++++++++++++++++++++ heartbeat/include/fields.go | 2 +- x-pack/heartbeat/include/fields.go | 2 +- 4 files changed, 146 insertions(+), 8 deletions(-) diff --git a/heartbeat/_meta/fields.common.yml b/heartbeat/_meta/fields.common.yml index ef6caae60bd..ec4c779e020 100644 --- a/heartbeat/_meta/fields.common.yml +++ b/heartbeat/_meta/fields.common.yml @@ -174,6 +174,52 @@ type: text - name: stack type: text + - name: browser + type: group + fields: + - name: experience + type: group + fields: + - name: name + type: keyword + - name: type + type: text + description: > + denotes the 'mark' event + - name: start + type: long + description: > + offset of time relative to journey start in milliseconds + - name: user_timing + type: group + fields: + - name: name + type: keyword + - name: type + type: text + description: > + could be one of mark or measure event types. + - name: start + type: long + description: > + offset of time relative to journey start in milliseconds + - name: end + type: long + description: > + offset of time relative to journey start in milliseconds + - name: layout_shift + type: group + fields: + - name: name + type: keyword + - name: score + type: integer + - name: exists + type: boolean + description: > + flag that indicates if there was any layout shift events + present on the page. + - key: http title: "HTTP monitor" description: @@ -379,12 +425,12 @@ type: group description: Detailed x509 certificate metadata fields: - - name: version_number - type: keyword - ignore_above: 1024 - description: Version of x509 format. - example: 3 - default_field: false + - name: version_number + type: keyword + ignore_above: 1024 + description: Version of x509 format. + example: 3 + default_field: false - key: icmp title: "ICMP" diff --git a/heartbeat/docs/fields.asciidoc b/heartbeat/docs/fields.asciidoc index 64910449412..0f88582dd42 100644 --- a/heartbeat/docs/fields.asciidoc +++ b/heartbeat/docs/fields.asciidoc @@ -10499,6 +10499,98 @@ type: text -- + + +*`synthetics.browser.experience.name`*:: ++ +-- +type: keyword + +-- + +*`synthetics.browser.experience.type`*:: ++ +-- +denotes the 'mark' event + + +type: text + +-- + +*`synthetics.browser.experience.start`*:: ++ +-- +offset of time relative to journey start in milliseconds + + +type: long + +-- + + +*`synthetics.browser.user_timing.name`*:: ++ +-- +type: keyword + +-- + +*`synthetics.browser.user_timing.type`*:: ++ +-- +could be one of mark or measure event types. + + +type: text + +-- + +*`synthetics.browser.user_timing.start`*:: ++ +-- +offset of time relative to journey start in milliseconds + + +type: long + +-- + +*`synthetics.browser.user_timing.end`*:: ++ +-- +offset of time relative to journey start in milliseconds + + +type: long + +-- + + +*`synthetics.browser.layout_shift.name`*:: ++ +-- +type: keyword + +-- + +*`synthetics.browser.layout_shift.score`*:: ++ +-- +type: integer + +-- + +*`synthetics.browser.layout_shift.exists`*:: ++ +-- +flag that indicates if there was any layout shift events present on the page. + + +type: boolean + +-- + [[exported-fields-tcp]] == TCP layer fields diff --git a/heartbeat/include/fields.go b/heartbeat/include/fields.go index 2ad529259c3..d7d45a800a7 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 "eJzsvXtXIzmWL/p/fwpdeq1LUmMH5pkk9/S9hwKqijX5oBOyq6cre2E5QrbVhKUoSYFxzZ3vfpb2lhSKh0kgE2dWNTnTFNgRemxJW/v5238mPx+9f3v29sf/i5xIIqQhLOOGmCnXZMxzRjKuWGryRY9wQ+ZUkwkTTFHDMjJaEDNl5PT4ghRK/oulpvenP5MR1SwjUsDnN0xpLgXZSl4lg+RPfybnOaOakRuuuSFTYwp9uLk54WZajpJUzjZZTrXh6SZLNTGS6HIyYdqQdErFhMFHttkxZ3mmkz/9qU+u2eKQsFT/iRDDTc4O7QN/IiRjOlW8MFwK+Ij84N4h7u3DPxFCSJ8IOmOHZP1/Gz5j2tBZsQ5fEJKzG5YfklQq5j5R7NeSK5YdEqNK/6FZFOyQZNT4D2o9r59QwzZt22Q+ZQIIxm6YMEQqPuHCEjL5k3vz0lKda3goC++xW6Noagk+VnJWtdCzXfOU5vmCKFYoppkwXEygIz+40F3n0mlZqpSF/s/G0Qv4HZlSTYT0o81JIFMPN8kNzUsGgw6DKWRR5rYb16zrbMyVNvB+Y1iKpYzfVKMqeMFyLqpxvXd0x5UjY6kIzXNsQSd+vdgtnRV2A6xvD7b2+4O9/vbO5eDgcLB3uLObHOzt/GO9tuQ5HbFcL11sXFc5svvafYR/XOE312wxlyrrXPTjUhs5s49sIn0KypUO8zmmgowYKe1BMZLQLCMzZijhYizVjNpG7OdufuRiKss8g8OZSmEoF0QwbZcRBwSb2v47ynNcD02oYkQbaYlGtR9rGMCpJ9Uwk+k1U0NCRUaG1wd66MjSQdX/XqNFkfMUxrd2SNbGUvZHVK31yBoTN/aTQsmsTOH7/6kTe8a0phP2CWobdms6CfqDVCSXE0cS2CWuRbcnHGHwK/uk+7pHZGH4jP8WdqPdPTecze1J4YJQeNp+wFSgj+1OG1WmprQUzOVEkzk3U1kaQkV1GGpj6BFppkw59kJSXORUipQaJqLzYKQdxIxQMi1nVPQVoxkd5YzocjajakFkdA7jwzkrc8OLPMxdE3bLtWUEU7aoOpyNuGAZ4cJIIkV4ur2kP7E8l+RnqfKstliGTj51Luq7n0+EVOyKjuQNOyRbg+3drlV8zbWxc3Pv6nAADJ0QRtOpn3Fz5/0Sbyzcbdtr/6xvMDphwu8ddxEcRR9NlCyLQ7LdubsupwzfD2vnjpljxJTQkV16ZJljM7enyzJbY6/FsWuTioVdCWpPaZ7bc9kjGTP4i1REjjRTN3bRcBNLu/mm0q6fVMTQa6bJjFFdKjazD3im4x9rnl5NuEjzMmPke0Ytn4D5ajKjC0JzLYkqhX3b9at0AvcgTDT5zk3VNamnlqGOWMW7Yb/b8VOea78jkUiqFMKeHokEsmOL5qdck/MpUzGnn9KiYHZf2snC+Q1ThVvAEkCEPTqW0ghp7Or76R6SM+wwtRKEHOO04TzbA9qrRpjYLUGcBDNiNGwpe66Pzt+ALOPu2fqU3JrToti0k+EpS0i1O2L+nEnmiQeMGQQUwse4X7gm9jYmZqpkOZmSX0tW2vb1Qhs20yTn14z8Jx1f0x55zzKOO6RQMmVaczHxy+Ie12U6tXz8tZxoQ/WU4DzIBRA8EA2PJmx1T8ZI1IlPy6jkeZZ4Pha+7jrvy878nee+fcZObw0Tmb3kbdc1Uo7djsC1+1No4hKFUMverVwkXANGhvNJxaKjPTiDFBcCpZjQpD0bhZI3PGM9K9bogqV8zFOCb4P4xHUQ9AJla/xoxoziqd1XQb59mewnA/KCzrL93Y0eyfkIvsaPf9mn2zvsYHww3hmM9waDrRHd2d1lu2xvNzvIXqWjg+10tDV4mUadEZiXIduD7UF/sN0f7JHtncOtweHWgPzHYDAYkA+Xx/+sUXtMy9xcAb0OyZjmmrWWnRVTNmOK5lc8ay86c0v0hRfe90l4ZnnmmDOF/IRrd65e8DFcVHCb6Y3mFuBW9lEzkC29IkBTJbVdKG2osgx2VBoyxB3EsyEcT3swu1fwgO7ahRi3CNRFli9/Fj4I/qsVmh9OjyC4WU6G/A/em4OEOGIEuB1fsnHdtLPWtO3PVUzcycXAnuMrpbXimlB8Cu9TlGwm/IaBYEyFew2fdl9PWV6My9zyYMtR3KxDw2YuyQ/uPiBcaENF6gTlxoWmbcdwq9lN5aQ0UklprKAKOE1om2siGMtQ751PeTptdxUuhlTObGdWmYvmfTa2/MhfXDBVvNH8R3JsmCA5GxvCZoVZdC/xWMrW6tqFW8XqXi6KO5bVX6K2I0LzOV1ooo39GWhulRA99VsZl9vphPiuFRiTimQiiAKB2tWzeCRcRyNWPQKyER/XNkS1ks2NUdsUM5pOrWLaTfpmW57+7pJYwRL8zV1H9UXoGOt+MkgGfZVu12Vo3RCgSyOFnMlSkwuQRO4hTB8JQqvXUIAhL44uNvBQO9HYDTKVQjAwbZwJw5RghpwraWQqK5nkxdn5BlGyhLu5UGzMb5kmpcgYSg1WFlAyt81ZnikVmUnFiGBmLtU1kQVT1Ehl5e3Q5ohNaT62r1Bixa2cEZrNuODa2JN946V721omZ6gKUEOckQUnMptJ0SNpzqjKF3+q1mMM2lcYscx5ugAtZ8pAiLHTTB4ssYlyNgqyNbnHpZ3LIEa2FsldQNgmoXkuU5D53ShbC+iE4PBxTVBxa+wae3F08XaDlNBBvqjuOI0aXlgWPFVnDXrUNunW3tb+qxYhpJpQwX8DBpx0X1xfSpABffuquSLxYCKDRb2nji+sDKObklnYNMuFt8bavYvmD6PopN2PUtpd/fr1ce2EpzlvqcnH8Wd36slH7n17lP0+p9ptbG64PWd4qPwyuwPupHyv2KP+q9iEqgy0Iqv0SKF70fOoEY042p+5FDQn41zOiWKpVJmu2Wouj89dq3hnVsNsjc1+YB+PRgZHWzMRtGH7zMV/vSUFTa+ZeaE3EugFzTuFY1CtrtC6aoXUWqdejVegVTBtx+HUTE8lo6jQFAaTkAs5Y0HxKzWq0IapGVnzJmOp1ipTkmJjzwndUERjghqPr/vamThwZUcsqPhg4ogI4I61HZaY+GWuuojHj2Ybt5F8B/b+LHVpCeJarWwLXNjh/asUuABgakDjgTftdzRW0VdI02rSiny4Xn3gAt56Gmyu2N6m7ydYzOEgoRBJs4xoNqPC8BTuFXZrnLzJblHz6KF45+1eOkidRpIbbqfLf2OV3chOlCnQVTU3JXXLcTYmC1mq0MeY5sES7e8ay5EnUi169lEvFmnD85wwoUvlZGNnpreiU8a0sdvDktQSbMzzPDBBWhRKFopTw/LFIywGNMsU03pVWiOcAjQcuT3nBuAks8B+ZiM+KWWp8wXucngnNDu35NJyxsBtQXKuwYB7dt4j1N/sUhFqL6xboqXdPwkh/1VRPEiqsaxm11fRuR+TPw/DxH0wRDLW5V9BuInE26xEYzpeu8OEF0M7lGGCwxr2SMYKJjKnmKBWIUU1CLBhRaJoJcUlz8JCRYtneeER8kI85tHCsI5z36m8NPYRWtXaTdQG+L39Es2lwcHpzrzbYsiyu5f9YLc1YDxAK1C33J2C/SWtcUyYTFJuFlcrMq8cW41l6Qq/sXoSi4y9tWFKYbhgwlylMlvFWC/nsp8zY5i9BDNWd2CH0azr5fN5e1Rr+x7Wz/pEV7QobyNbV+i8e0JSmSk5mjHFU7pk8KUwanHFtVzVOh1jl+Ts4h0sVOfIj4/uHO6qtr8b6tIdc0wFzbopC3fa/W00EyavCsmFWTaW11JMuCkzFMxyauCPzlGt/zdZy8Gh3n+5k+xv7R7sDHpkLadm7ZDs7iV7g71XWwfkf9oXvR34015oDbO1ZqrvBa/oK1T5PAl7xJnhUAyXYzJRVJQ5VdwsYglqQVIryYHeEUlKx15ACsZPPD1coUidMisGOO1rnEupnDTRA6PelFe6TXXl4PByUkwXmttfvPc29TxTR0N4K00UzgJeao5mrRlIPhMm/Wy7TYEjqY0U/SztXLNCakPzVZ3g9XPoDtks1VqmvPLvYrSEm0pFgL+5IJJKZ3BOuuCQC07mESPXQs6F1RApsVODjqQi/zg7J7U52qMAAvkNVQsy55mV+eDKd5wCXXvwazddX+0OdgePYfuKTbgUq2Sc76HHT/HN/l/b8lY03hVxTjfWpYzzryUbse69bPWq32Kt5AlFhinD6LHfwM47rm3eXvCRnx29PYqeWzopd9FuHqkJiB108/uSCamvjrhqCKv32GS8uCcFag/W5nd2HvRJLy+gfPni7Pxm156os/Ob/Y22nDmj6Sr4yJuj4+4BNtw8Qprg159RJ9S//+GYvBzsbkNkBAZ1suyQnFo1T6aGGfICzBlc98hBf8Srm9XqDhvolHcioosUnEvyS1kUTKVUs3+SKbulGUv5jOYk4xNuwItmxUk7UgiLC2264WPHlnEJUgrNJy5sik2YSshFmUI0xo170AXVofcPx1AJE9NFMWVLboPBoD8Y9PdO4edOf3untYKCmqRrBy29x5fvovVLRYVGm9jZuZ2psxBhXO7bo8tgbiUvWDJJnE/C3hCxIRhsi95dUXPJh4sxsjASoyi4ucSE5JJmZERzKlK4p8dcsTnNc7ToKlna67vDbmGJUEhlHm+28OqmNoovt2fEFLL9/Z5ohBbOR2rjNSqcY0uP1ru322PrXLuHmAnuXrdzt1Yx42mOwd6b2jDFsqtlVoCnkY0t45vyyZRpEw3C0xPH0oMJFgXL/DR0OfLGg9DyD1XsAsq4UXPOYmllsbWxlIl7LknlbM2yyLX4g2ZQBUYiu2CJjBmmZiDJF4qlXFtZDERCilZSiFCDaOxylPOU6HI85rehRXjmxdSY4nBzEx/BJxKpJhsJuVQLYL0ShchbbiVnFCBHC6L5rMgXxNDreL3hPqfaAGvHMGSUF4U0BAyBc5bnMPvL1ydVVNxaKpPyeq2b+UYUae2WQP5V7pLQKRyYoD6NS8sufi1pzse8WmqM/sA4z0idyXO/hUB3Iew2ZYWpwjHhtcpH3joWCURPUFJQZXjkoiGtEQBD4tiX/Z/7HqWuSscDZay0a2V7TqmofDSkvt96EQVC1HZrQiOWy3n39u8+K/XzFNN2bT6fJ4xqk8wWrgXcMHhiqDZrUUwJDsK1MqW6CrqGuYLoE7qppM41XY62E12OtmqHslfb3NXwUIlyzgAfzVi1sdbDsyikvTR4DoEETHG5JLDLTuKhEquRxRVM6StwSjYe20vxhtlRuE3kKPOCXb4+2eihchk0y2pNQrvIbnreyQuMw25nv4+iA5S0mWqz39BsFDpmVxD2yO+bmwInXcZIq5W4P0uF71r7qdRMJavdSrFtFeMEpELvux0MBhzNGHia5HjZFUsFeX1ydA4h1UiJk9BUvIfawhjMmM0o7wigfpIJf7Czgg69ItaWgGBQlhMvMR78oX1dlkDrurqIwCRIbyjP6ShfYgbIR0wZcsqFNizaujV6goP8m9ncMJrV7G6c+MqCxduB0T43AOfsYzHBibxZ5NRY1WHJIcCxr9BAHq8Ydt49sCnV01XtIkdR4Ie2XzSxKsWs/tvKwqCOcQpChRSLOG0OtbRom33QzEVbD2FWPMP4BfjDznYYBJtUijGuKc1rfVKRdciKEOW7ZEOuJEB/SXw+knHJoj6dqfab5LQXU6uNo3sG8q+46CZSxGopsNpu8imZdwUZPMmhOFKKQpIlbHbo2fuswG5cT7/smMj6L2vXfEQFvYKo4bUeWVMMNA4xubKN+uTET9C1isqUZUgO9UGZ1Ud3xWRiVjvB8xxicqBBUNzEWNGQyVpNC22ZmIlQHXDISHC/d+bfjcmbKveJ6zhxggpyeryN2qc91mNm0inT4LP7U9U+4Ua7pMdqoJYl1DN4a0mXXIfA+/oQXLuqFC6bUrGZNCFMn8jSaJ6xqKfmyHBMlLhkPz8h17AL64JXnb+xnmyMjVYNQV6j69wb0GyzXFdDdQR7TAheCs6x1V3H65cV4bBvyPOMA4p4FrJ4HbtckIyPx0zFZlLwtnLIWLVCi2VofcMEFYYwccOVFLO6H6Hac0c/X4TOedbzgUpwPsi79z+SswyzayE4t2xy7m4NZn9//+XLlwcHB69edcSMOTKv0rXeJrRnrTTnVN9B40Db0Pbn0RjF5haVM66LnC6awmJsg0Dkjn7Gbh5qinASOs+5WVx1exOf5iKI+kVvIfeBlsB1gJlVbK7zLih1n1Ft+ltt/6jPJVrdgT3zuWZnJ/4Wgzl49tk1Ad7f2t7Z3dt/efBqQEdpxsaD5TNZ4ZkIc4mzBbtnEzlC4YvuhLcnGeUbz+2j3LdPktxsJzOW8bJtkXY4Ol+Fxbu+Y+bZxSxqrOE8vNMjR79ZEaP6ZEny9KLvOnool/C0+Tp82VMH4wnuSxfkpnXKLGehswV5PG1uePagkO8vFtToyQMDSDxFYiAaOtc9Qi0RemSSFr2a3iEVuutpLlNGRbfmMNetKWOIzIom7CJkPuN6aI3f40t8ne3sJVOfXRyjK2RcW02m5Hrqn9MNyRhgSSoZxFtiECUHBBC/IXqETUDAsNrBjSav6WyU0R758fic/Hh8Sm6qlT0qCnIqJlyEI/O3N/YV+7lDuug6eLQoCHOv2d/dkHtupqoUPTKmakIN65Ecuu8+fvjdgxQ3mbErzSeCWvWqocHJjJGLxnd3qXKXU6ZZE4GmZi0BfWjEBVULDOcLXeuHJ5QiuMA9TRYjKXNGxbKN9T1+DcYlWoCqyTG31o3PbjEXvdOtURtVsnvpzLUjxCd2T64QzMIeoMgs5MVyOxB07yCCSweeQUuCdzgzHlCLzKgox9QhTo0WlnoeauiGiUxGNpXLoIlCWFTObigGbRwVlvN+9+6CSJEviaFM5Syx/bLktkiTQsnbxYPpbqgpV5YKdpRl3CWAtk8D3EBMGXRJMze0bvqPy9yjBU0gzUAtCiMnihZTnhKmlFS6CouNW72hOc/i8GWpiFGlNr4/8prRG0ZKEeU4jn3gGbxaveLvzar90OzcqnoinbL0ehn4zOn79+/eX314e/n+w8Xl6cnV+3fvLh+8fiUC2a0ovPQCu6sJ8oF91WSWKlmFp0ra/U+OpSqkagbn38/DzehsxbzBdvklGQS0J5XjAA6wwLMFB4qWVPygsgE8nC+c/vWnv//j4M3B0d8eTGe7rdlD6PyJ62T9wkjF0BIYH7OOo0PSaT0k5G/2vFHj4z6XHTl8D8LYETPPJ2P2wEZo5bvQZC1YwxKwDpQ2WhAjZa4d7hR42QCpiKXXaAVEHtFJ9cddfMBUviC9u+9v9DyCaF6/yW+YwhAhOqFcRKEn9o0gn1iJMrY3dbJIWluUe/C/+xOsEtJAlAqMJshn9Y/vRD4ID9ez213eeQu8M4ILdABjrtUwFuKinUkFw2p3adRIhAobyYVTlheRAw9Mzxi1GprWzqgtFlb2NTzSNu8vHa7Sz1YRhWdtow6f0clKtaRYuYXOQ+4eDtJuUgRnkx1JnzhcQycrGm21M91Y6aQjKqSGdXufIdVwb8nd2LetMZ3BSByQbGssK1zKijj1NJBgQ8DzsSojAvZmJX06wQuK62pjdSpGiM9b42f2zF9poxid1TnaiWUGF/EXn0Q9jdryHMbQa4aBdFwgzIK/SwWbO1DFuA9ihwUoLumU1WxjZ6LrtfrjVXJGiHWJHg3KMEDaVteMbCYH2mu3pHntZee9G8s8l4D2O6NCMHVIhv8dTRuMxf/Tr31kf9fMND6FwNSCpux/hkldepsx6vyWEfYvCAohAmJKAcNbeSlBOc2AUO2jFmN6MpB1otnohLyRqoHW4jYQxiCOZSkynDTXAVodYl/RM5OkcnOUy8kmFX0uTEDU7RvZN1PWDw4camgfe+3jWvVxrX6xb4dRFlKbf0arfSTIKbagGVXptLYWqRSaa6ObKF0jml4j7mrGU6ZR+KpMMI1tA1mIM10L82y04HI5yUnJcJvgCbuxMrUUva6WNZlZGRECTnGz2MbYrd+oimmjuEfSqUVXLTkNTLuoloDQO/w47JHhpv3xnf3x/9kfa/bH/7I//l/74/+3P8iQvIBNVm2ZjWrUw94QnJ3DPw8TD6WvGR6iOvEBFYiJFBM3aaVCL9kYk5JnbJMJD8CPzWyGZjbTUikmzKajcz9VjBrWB0olUzPL/9z4hha8X1Az7RdU0Zn+JSbjP+8tkcRMT7PqQlrGp7E9u90MFeaqya5rHHCtsqPYMxSBypop8jxqyAxwmTUTmnlFzilnHyN+/TGS4TwTSz6KFlLzUEy4uE0oZJbZ9S6UnDEzZSX8xUQGaeXDetvMpLjxarsWhgdu7zkHAdEgCip8nmExh6kVuR3tiGam3u6cBYApZMEf1wBkiacf10LknX8bnkjIEMNi3KdDpxbV24VeA2giNk01GXbw2GHyUXzPFhJ0rsYmrjfacYWkihumOLVTtdqIvYIxTmMYxoe9T6mODkG94XhjHn4UhHxH3liGEOPtD/tD/OathOQlFOAF2RoMIt6+FtoN93e83tEuXKrjxUIS8IEvu+OPMObJJ/GHXhKQeuHXoNs4VCsKHBFOKBeTOuncHZV8FG+sumHb1oTmitFs4eNEmEve9wwa8WrpwivauMMah6lLUhBy7r0KrpUR04YUlvg8ZZiA7kibEDugeqM4OoiD9yponNEOhr+he3+YOEDWUN7CKnuAGw5YXfWW7R0EIE7h7eWbun631HdwvVW3nYdhkeLNDDJPxdXv2MP1Rj97Q1dI/A/ZzjWP/JfYyetHgsgbpixJgVcvClZjWW4PRQIKIcd4h+UL3NQsi52Ua7mc6DXYlGuI8K3XEvIzI+y2YCniwFkRgWYZWTPKnpS1qG14Ty+EmTK71msVRh5VZFyaUsVO38rnJCf34AvhFqwQ3hqif+uLO0X/6PFKZEW7T1PAZL48Sx3Z8U9+HgiLt4mJqUndWAFGygqhD0PtaqCBPZfRaqUa1yQGcjnoN9ytdoGjSgS0EzjRL3TH3CIowk+BEOItPg61gohztyyB2Ys6ABE3gzw1lEs1FLGJQY0RS861OvIAfWAGE/UZ62UdejLUiek3Q4wjWSvmAzs3tO0N1M7zVEcbgPHGhRwgQBauVdH9nKdCmCXCggRK/67QBmsgiveCHKwONVY0+kKQg6FZgB58hhx8hhz83SQH/C4hB+OD7/EPXHm0jsF/VdzB+Ip7Bh98+FifwQfbE3oGH3wGH3wGH3wGH3wGH3wGH3wGH2yN8t8PfDCWh79dBMJolM8whN8oDCEvwFEQ7adP4OyxGsBeofiNvQRO3vxjowtiD65IuFC+eeRBgLCLIr7c7CEOrKKXkXZRLXVOGKSIPM2snxpL8IEK9dcFFKzxkeZAvjVUwayl/z9DCz5DCz5DCz5DCz5DCz5DCz5DCz5DCz54ws/Qgs/Qgs/Qgs/Qgs/QgjXKPUMLPkML/q6hBbPcSxA+UvD1a/fBp5KD7gNGAe6WnI8UVZxpki0EnaGByrWaS5qhNVP63GfwdrmvIWwYS7RDpK8re+xqGkuypqcU6ijU+llDAbjCHwHFzitEI58Y4zQhZrA97aKZg07pE4MO/Wi+Iyc4gX7OxbXrb0FeDJMsz4cbrua7N75JQX7mIpNzXb1/gcN9hwnvL4aJll3vfRD8tg+Ce2vurbHUhrHI+airwRlN3108PMyujl+S/AEgQRozekYI+ToIIc1leAYM+V0DhjSX898DP6Qx62c4kdXAiTTJ/owusmJ0kcYCPIONPJB+VhlOZtneijjFm5M97PJR49RTurWigV78dLT1eSPd3ttf3Vi39/Y/b7R7kU/7yUe7t7X9OaPVGWMPifz4rNFenJyenj9utCsSOWomUqeANS9ZSJWGWIwZLXQXKMWY5wyBMvV1N4O5ZkqwfGc7qfT0e5OioGZVtr4fyjzH2dhOW3TpmNjx4UenHH+8AMV2Z/vjZ02WJZDqaVgawWk+9byPzz+QuFtiqJowE0zHliSd07/d333EDK2gQMViRZM7CzVNsdvW1u35dOuMUANP8Zz1AVDqyWTugiXRIFdNiUZc+SMJcU6bwfn3m7jt6goqxK5+5q7bz5j1frKTvNofDJKtl7tbe4+YPp8Vq3RfHKHTIgB9FVIZV6Di/BRPNjkSxI2K9PsQrQKPkdo4+33vq/c615iLCVOF4sLB9UJ64Q0ThI4NU0QxpKZLv/XFK6zc3Yc5VzKuokIHE4ZGZA2ZAhhL1nMZmnMM9YBEbITVMYpWgC929JjnXpePlcCHqamBwoy5YmwBzAjhgsxUMWr6ijlMmO3B1u7mYGvTKITe6c9obhXIPhKnbzvkYgKgMEsiUdP9g8FOustebW9v2V+ylO692t+hNNvZz7LxIzaPVHzCBc2v4BCt0DMXTtDncs+L86Ozt5fJ6d9PHzF9p7uves6u28+d+1q4Oj7eHp16qzr8/i7Yx1GMWLsPcYLzQ3g12zs/3l64D+50friiSi6Tx3Z+8vaC/FoyOMgAUSX0nKnqQNnvXWElp8kzDmc6RIuD6VtMchbaWpBCcQlujgkzMEfXrGv0xTATGvDJDuH54QZBuWPhO4lbh8gEj8eA7k/ntjEhRx27DRAPGoN1aC1Izo0B7Q1zhoYhXMuQhgPttEeJrw43HpPwX5v5fTZwC6GwhQ9CwRkXYUhQ4d7C+CSaTl2/RGONdqKYKZWIehuh4Uw34ecvodITF/YcOVpVefZ+UZD2mrle6zACowU5Pb6ozsN7lkqVubaAzwN3ji3Ys2o6+KXvXJC5fev0+MI130wos+tr9x0io0AUNuQlMPimjvlhn/P7mxwZMuOCz8pZz30Y2vWTAvS0aK8h+NLQDg5QKFrT4LoKnOlZ5Sk0CTGRKVzKHCyNdkZUk0JqzUcYdJIBAouVVyP8G49dKKMt3Boo1SQttZEeV7ALyMDNO83pytAnsCgDxZyWsEgeFrKC9FPMZQ0o2CmdnPTs7dIpRYXYnnpGAVoyZqEYcOszAOoHiVGsiuZTKPHVgolM+8AcAPgBruZJFTfoadIpbmwNEv//S6mzylTWy3oIqd21UVWRxpRIwRQEMsfAmmDKBBOzHJPjt0dvTgnAYTm4QpnfWOkwYnDr6xqBpIYRmzIRdomEinVwWSvFdCEt6YNrK2oEznZCzgK/E9L4MNFmm04mI8NfS6YDGMbQXlusBgxTWy6Iqb4jtN4vmTEPCY68K38lJPdB+tEN+A3tlQBEAKp0row379N0WuuQkBEbA9Orga9wnVKVsSwh/2BKeuipGZjCpy5IBPlzRdhRPZAGu1oCSLF8c6+wHtbltKqF9Rl8DPZ0az5TRjOmrsY5nazOmewjeraJg4ywLBpHQmAktaI0BUtNDVfskBwd9cjlcY+8P+mR90c9cnTSI8cnPXLybonT4Ze19ydrPbL2/igO9rkLmfvJltLOFfPEYjck1S5J0UlHhZITRWe4jdEsahonAvM7mELIpLgxAGgteIXug+xHL7EybG9ttWspyWJJZvWTEsbF7kiB3mgUAhHv3bkXr7mAhCyUu2uiOP6bMa3phCVx4D/XELPkaOuYqPHuWmwKxXugGoRWNdu9k4Z//XD6/r9aNAw8+qvJPspJwHiPobp1bzGndsWs8iaHK7wx5PimDk6BRu1YIUUfTERWDI4Bol9ggtLONsCE2VGQre39jTjfR+raG9UlEycnU02YTmlhzynVjGwNfFKxJi8+npycRInc39P0muic6qlTcH8tJUAkhZZdUwm5pCPdIylVitMJcxqTQ27OY5TuMWNZ3ALAMCuX4PrR9MhHhW99FLBfmfNtP04qCOv/zSVrPidofosJmmG/fOVMTV4zvriZ35Ve2WIuv7OEwvl8vnwxnjMHnzMHv2TmYLWxvo4K5DTFT0s0R0dHbRwzr8pffSlQjqOWRTTPydm5FTgZVDcdxtaiYcNM478cesuq22d8POZpmYPBrtSsR0YspaUOHoEbqjgzC68Sxrt6Ro22anKEv5+Q01sDmN5hfBEQqx+omTLFEHNb6CQi1DA0j8j93ATrIYRDAvq2mbIZwPVETaMsgi/B94xqDlkIocUbrkua89+YE5GsJD6WS2rMr/+yFhmerD5X/bnVpdh5mf1rqDK+7+VwUW/fQSBxa9QrPFjr8ckKHhcfRJj13IpYqRk2av2qXMhSRVUaIo8NBF1O+A3T9qHY19ODD+LYTCxuEdrNhA6tjHFsTafNfUdRDcB7YJx/pjaIRv9SeNzigik3/xeyQKt4vrBNaCnDbeX0UDxGGwk5EhmhztIV2mxBb9tDuNxz5P0sVjt1zKPzPERG+VCCNm34506P7+Ofe8MM7ccOBV9kzXkMHl4Ld2nQRSOwTLFfS65YBjUPv3DE2enxRYjCgEs0rAMWvTEyIUOW6sQ9NMQ0XT+kiquCuAa8rNQGy/xCWEOeu60W7cifp0zg2sJCp0rqSIr0JRv6fWegdg4oOyAIQ8/5ZGryRZWJVVnCqtnA+1FCVs4M1pueKBfVQLN/2aF6kKB0yma0tSZx6tySLbaVDJJBfYcpJRt1/06jjx6QAkdF5G11qR+w5Rdg5Qk0/YAFVWYoyOBzzqVXFAxAtXNGxsxg3QLPPCAzNqX2ipvj1RYsOrgPuNEsH0ewJgJbf4SvdUUghEBoNI013EA48HtZNleQgOuD+ZaMypno7jm0RlpsB0G8ya/VkTY0vb6CyhJPd6F+kxm/l5jGkEJBB19EyXJAIBgXpMjBt8xua6mCIMstxaD5OgJ/2Ei9WGnD/BCwc8ahMgitVIMci7jZv+gNTXIqJsnbMs/PJTinTv0rdTZ3U/Fez+aijz5ZBhBZTFdpU8isuDVLEumqenBYBVXxtMauAlc8so8SQMd1RRR0q+ZFo8oHlFCo6nAh+6y0p9cyME+453yFrZBqTU3wqoJWKiZVGyQU5pLjaBKuPd8U9elVdnNCBjaxswcYrF5UhcQ5SFDJCxh4rk0fbgF6cozc1sMqEL6RVArhglBGzMytmkPjUhu0XpQDO+OCGwTUtUuVS23nduRX4tPkxlJ8rkmI0xAlIpPmZMaoLhWbAUl8qaY2ZaPHIKPG0GsW9nNM5nh7VDSesZmESCimbTO+uayitCuBcsMDWzRsBp6XUrGEXLjyd64umb2Lh65sJQabOGnKR/jUy+GFExEHwLiRQoETQ01L5nhAVFP6AFzvz1aNsLegD3kPkgMbqFuKAko1Rr/G0TkieoucQZFi2BqVlD2lwtM7pYZNJKg5vv2w6JaRDIFMfZplrtqdPU99OE8MPhrznLmSgdkQnYPeDRZatNcMqDNR7JQL2s1h57ElOnipmeoXVGtL2D6GxrXFITeF1SwTZmc6EOGx1QatqHyMY/A1MzAAES0SIIRTgytVGRpBZ3PWQrdktiE/GTLlWBwrTltprlkl0eI2WBvxCRmVAOa5ZscXtchZo/hlpHDkhinHHRtdHLoVH5KFu1yCFkIAKMZZEN1joU3Ic+Rm4RyjIZUdeFy+wHddGRvs0S7O0EdE+/xXGoOw63Lkh9U8DaF9r826fsE+iQXwCiWtip3WF8rdU25KkZmTYqE4uzRBnYoo2a0hl2ZqpdJGNYC7xfansbSc1StEgRAfoj9d5S6OpVwRNCKiaFRMyUcalpqFyweq90V5yU4e1qQUUWWlHlFsQlWWx7sCbhF4mli5qLS/SEXsNEF9BTUSLyx5wxTcVhDE78UwL1jyeKmYDzhGmYmcnXQvz+7+7kF7UZBz3ZN3ZLHtpklzd3KwwUrRc2FBbBPu3rmvwuWKTVG7eVWUFasYRXAIQegE1kkq+zcYngpeQFGypfs/41Y+SR2K7/+GElaGzgpkMdTEH1VFCtxYazSF0TK05Prib1E8Q966ls4EmdnrXnNTol2g56JnzVyS0K07lCPWYX3A68P/GalRjfyMlOapr/9oldMcArlQ6IoNdC6UxYUO47avGEosEsGywKtAdFyTAHiTEW4cR2mMZCYFN7IKVa2aWF8Hq4BfMfsnHfGcGyhUcM1YQcoC3TnwUnzg6lRNqavx2qCjvZ7xFKY078UrW/nsG3hZsXl7e7C13x/s9bd3LgcHh4O9w53d5GDv5T/ahu1m7d4VpW26bhtxk6JGKXR9QdQDJs5MoXJ3pc9ZtUUqf2UhSHmjmmsuJz2nquZystGLO4+RGFB+WlRl1aJznMpZhFFlD0s8bNgMkDQ0A14PEEdCmmD8g+atTFXrG1TNEMM5k1mZV+RGDEPEQPJwMpk0UZ2/uJklF1ZB0ylrVrcNy162UgAfAeHd0QoXRWmu/AOCCuliNaNnZGnih6h+w/OcL30OHaSwh7aWbq4TN5SaKZKAOzcMob7bkMfhylh+gX8zq84pX7rEVI7bWmhuFx/zTAp6F5lXUey6806kRSYeEi141/VUDb11MzUvJdyj9mL2n3txrmYjsncX+ILlCFTbrG0SW2E+4E9UT8mLgqkpLTSUZTX2kyiVbwMcunTubksD5Wco+hVrE8vYTAptlCUNmD3A1m2l2a5DtLW9s7u3//Lg1aDrt6Pvj0++qqH07MTO1KuLn0CvO6C7473BIGuPWGCpjS8hJ12Gewr2V+DoVCl+4+OMGZRqUjT3xYClakk9IO94CDkQUIbVJRjrEo397UWYfBFSMRPHpSvpINey1XpNwos7mDGHrOMBUTCRzsoQdkCRzOHkC03nnbr9mXDKsj2laOSwaqTWJZSbFpLYuYG21gvSi5MHvIdxqqSQuZzUcPzsNSevfcgI14c1WpH/1Zxc9Ylf+uG95Yi9ZGuw9Y8Hw65c8y5m9w3r8D5Y8FFKPBq60GlsG+r7Vpp2WsgM8+JM/LVpla71nB0juuzLzqYZ+VeNKyUYfN6VrajTOuAi4b3mhbwT1YxJyfWU0Jwp4wUsOCc1S2EjBgUvynprDZka50imCPKvMQobRlDL0IwuVTKlIsshuHXKFuDlnFOl7JmsjrBids5guK0+RNEHCKJkXs2am6pI2ZTlBUb0aQNVyKYMUkNDvkcqZ2jMJdSAR3dS5lSFZJRK/VVW6FsiiuVd+KcNmW9Fgjf2GqVyQYg/zLEp2bqACKcGgaKF/K0sMB/fbTcoQWHVf2gaNaO8nIAU0rYeVREZFE6I8NI+yu9HILbCHb/R8+cJWx424hxrKm3lugGTqH3+Lrm4tRr+3ljFery3FwS7NcFgYre/MFyF0/rBHZc7pJUlRgKreYDvjaEEmsn0Kiqkn3FtpaIMjMcIwQzqOqAHsKw6JFaLcbFfELpuFGc33lYwvMI1G0IOaakZQC0iyrS8YUrxzG0xGrF9H97lh9sLZdlJqb37ec7zLKUqw81pid29jBesIFuvyODgcHv/cGuA3ojj0x8OB//3n7e2d/+fC5aWllD4F0GchBkVdMIUfraVuEe3Bu6XugRs+ZTG+l5YpEUbWRQs8y/hf7VK/7I1SOz/bZFMm79sJ1vJdrKtC/OXre2d7ZpqdIdLVJbG6pm/qzvSaqePvSLdfIc+FjVjApIaYgaMF19kB6d+QcA9V6nklOdWMAt2rIIpn7IQrkEo64l2MkRGYFmnlPZWGpcuhBKsRwaI6veTyEeT1azIyNwwu7Nxf9srxwPeRZdUdQU3CNOz95cznuLVzitTVDTBaOhH9kYTYfxe1qYY7Ql3WSFLr+qSF2Fu+LdLMUUxIzRaha2j1OnmCKaUCse5Sq8PmH7BuIFigW09utZ1iA3Ee8SyDZrn8QLfa1lv4sAmt7BxcOEPpYL9VJFFuJR7dxGBxRJS+q0AX1VBdeuwRHIyNaZboY3ZxisSjBued7szfK9mGntHDq1gNOzF4gQViyB5gb7OIWPYD4xkkiG7n9HranU0E3oJy3SkbbEeByGhVuW/uAgRll3nD+38cNpQyvAR5hcL7Qx+bbfAazmJTN4zlAVr8kEV1ul1Un8FdlQUrnBXl2RNVtwJpZaLhZ5Z4XNqTJFtgFkf8VvLEUKHh3KSDUjx0OILBGDrVUhdfTfFvr/K+kel1RrFZOMuvLrW8ipG9cowq9bfQ29kPl3EgZI+uKPN1NpW8Q4XuG0N6Al1y1KQwB0rtpR2ByL41mte8tDuzxC6584cvj2s8yDXZOA3zpfmXkE6DjtqSONkHQKsnXwItWgUZSFzNiKA2e1yPURjPFGT9rRnTHB3TSkG6RKV5hLuksbwAtttrLsdJG7W4SiX6TXLiOaGDZdspktITwEuBpVPmc+ebsrz9zQAAMp/zV765BvRdUg+vH9Nci6ufULM3Qjkfs82d6RvBSsVQPAJT+NglhAYh8zlKFKde0GAqoHXRNaCQ9AR7aWvGN7UMynANQvXd73GdveKeZwwZCxx9tgm9LP558EAjJcPXjqur690Qw69Szod55IuDbR8z/U1gdZAUVRcKo75J02mqh3fI1rmJVjLNpKaiP5BM+cShCmDU845MFHmsCe+o2JomM+VkGr2gA1558TW34Jxj//GMujiE5PsYRSVTin4vkOrA7u/tgaDDoPojHJXV8JV4FnIEvZI3T3mbhzkSIAGoKMB6bqX1DYxdwZOzezeE9U0kIou8hykM6yD0eHM0JY/Pex4P65M74XryNX2XyZGQNhq41GIycc5edciONd0KyiiB/5fel3HTGG3NDVEqsxF1ASjVRQdEcdG+LFVztvgyuqk4A1TdT/MF6+qi0nxGEYYOqyfvdoFfZf3+ueAixKUmdBijJ8SZaLhU95R5gNQYhuB53g6cZ7VsvCCQhRQFlYHwhJdr9yZOMCooE2sF7gdHNsxQfSwEl8n6JGTNcN8RsySGxAoh7mcJBq+T/z3SSozNkw8Q/cfV9d57EaoMhUQvMx10RKMaq5w5Ii+enR1hM9OLjYSn2xceyOoB26rE240kXMResTUJStPVDlJod1UFhjGt3y6UXxXmHD3zfSyvdcNfVBF7087P9HT+kn3pwtujB2gtSvFO0Or4J07PKD2XP8mxQpT7O5WuGtTtYenYjx2N4R20UboQrLdHOqyUK4Yzby86IQEfygqr1R0HeNh9RsJMVPnXNesE2nKCgTUCJ36LFPA4qGWVUgBauzZiet87bRUsmCbRzNtmMrobC0C26CjkWI3qK/7xy8u1zZQfSY//XQ4m1WMh9PcP9Uf7B0OBmsbHWy4OzfhG7bCmSlXjww2hbjMuoGtEUO5pstRH6NO10Ci6OE2wwjO2h0UFI9WJCtuWbwTeoQJuwd0FJrq+HIGERcyMuzhpCCDvVB2mUEQdkYrn/Dr6sIvsYc/adCos5stCtYlEpVqVQVi15sqjoB+AAbWS4MSmCMXpT3qN0wbPvEzrlu17qH9CMREdk1jThwX/YwVZtpqHa8556WsDFzonBdxRpHLGBagPJMipylbqkct0Z8q1vDZetRs0aFJQTebe9svtzKWjfrjvdGgv7u9ddA/eDke9HdpunvwckB3DsbsPlqW3yljHhyBLkPoh+qTOxOEjhD5v5FNAhhVLY8yJOpoMrKyVz001iW82G8hYtineNi2HRH8fvgByiY40E4n2kVWU2AC4IvxK+ZzaPzfVGSbUsVTjuP3eg5AKZjoRwvs8sx7vsibyh/5yw9nb/7pgY51lS1jL2yeMr2R4MsuecoZOhsZJWD5AVALliE1G/PxKxPFmDir7qOyTjDq9AsJP+uvqYtDcWEpOdbO8d10Oja8BbxaXo1Bq4AaDpY2NMIvCVyjxig+Ks3KKndWQH+4PqH/WLwIH2LFSWT1N1Qt7B4KNYPJT0xhwC6AfLHbKS01eBQAUkWO3T1V5/yWmwQLmM9acscZalDcsB64VwCuIutVlZvtfQel6WLnKrtlaWlYj0x5ljHRg8Bw/ClFvug5ztojc8XNEmv++i9r/vm1HlnDN+5ZgJQ8l5l8LjP5XGbyuczkZyznc5nJp9/Fz2Umn8tMPpeZ/D2WmVyaevg4KR+0GGgTVDmo1XJPwR6i63Fz1t5vi/VpLZz9y+slldjuNCiKEbaQ+d2tqeB3oXYENOMWGuX7sgAr73Bmuxo6Iw+3Z41pMoQZRU51l5yIuahY/yb4AeyjPaK5SENz3n7kxx1X0emgXw0H4T4E/Jy74QQ6c4FeuhHiYu4qf6cz2h66V1dWNXrfXwWoFAwZuQQ2GZcxiPFDMsVv6jZ7hH53hsnIWNg5+82pnLFNmscrFahgm77C5r4kIZYekhMFiidC199BibpJEy4IfxdX0qXwMVGdUflR2mhRMJVS7Qq21JwBIFXlNfdkDPz/UC4IJFthxTzkk6HXHmG3dmL+qs4Zhd8zeUfAZ1gAEDVrwL2hYU1eeKOgoSqZ/LbRg1Wp3UuYPidi0ocIpRdrk9/WekD7NWxhbUkcThFZ2D1ZJyuTQM8Vn9nLFSxb4JT58exk45MsZn1rMNhqM8jYPrbakTdroHWOupspfPWC0d9QRehvrOTzN1bT+fdZtJmL1UGXnNm+Kn+j58t431Ws17scqlaijMS9/Z2DnTZvmfEZu1ohrtybszenmLnnZZRYyUaLU73UtCLaKFC+x2S0qBvPicuAiWt9cipoItVkE2O4ADplc8YyTvvgcYx/T26nZpb/cnb09qjWqhyPecppjj7Kf/ackOFBlxPEGO1AV7CSL5odRw4AvdYugoGEzMOIDB6X4qHbcLa6XfjGbsJ4abggMrVKZ9iZdCnw3/pgf3fQsf2+oO7UoToFnYdCchsow23Gs8LqKm+bldRRhAwgopUI5rNVUbl3Yn8nab1I1SXyyLlYWYICujhth+tgQ1MAsnF/ieFpa79/kyChUIMeys9HmnqvsSmCVN2h2tX6Dmreo1W7zbv20nO5+udy9c/l6p/L1X+xmT+Xq38uV/9crv4z5/yNlquPiaP5b5+R39JhqbQNWjYB6mB0ot7FFl4UfgCL1wXsck3W7J9Lqi1t7e8c7LYGj+LG1b+hcHqJghaIpxA/vJhBKGtHQP/q7Aew/qA4v8BdnnEFQZhudBuduzuKmozijFdaddYqRGAJ/gCWYFWl6UVBCi8uGmZi1KceYiy+3Ru8SmgO3MHwG2TEq4ofeu1iAV2UC4nG4aILX1wcvd1IUA8G40oINeyK0bH/aGmmmAYIBWIjLzRsg1FpXLhyBdraqIF18vaCNKlAyAvALXKwKXoDvTpsRnlevdtN+O8SllNteJqk8sEeblgfrnXJVILjXuVV6RfIBXjDpfHi+C3sOTsoCNWKSByI30kJh4oOVmbyE59MyZHWpaIiZeQCkP3J8dHnEagUZmXe1Yo40Ct5cbyB2M5dc/9w8TkTi8DCWLbKDXASd+zW/+Sx63/8lw8XPfLuL34fnIm0R959+Eujrm2PHL/9yx17pXYsv8i+yWVK886c0CfdOL5bz+teb3SKmXZ7WS71N87mnzNLqSZUuAScFc807lqTF+8+k4GcifRLEYLmV6XgqxLDu+hBc2JHYMny4ZF0WVYY+hG0gWofV1JdgTqwOiCJIApAtRHI5sf+gyBw2SMXILqddx6TY5rzsVSC00dNX0hzBar+A+Z7l3fhslUlJl5OQJADzQWMCAjPhkgAvLs46vZge9AfvOxv7ZPBzuHW3uHOq/8YDA4Hg0fPdsTGnVgTTzNdTPK951S3XvUHBzDVrcPdweH23mdMFav2Xl2zxRXNJ/YMTR+CRfE5e/rI9xfMTB7iCCOKseTwNes+1O8vHnenRRNOS3Wzygpg0B9O1hfeyXP7QOq+qqZMwmJg3FXtUoeC4J523v/ZSSTBtSn2trc+l1LstpCCiYfcA3fZHU5dc2HhMwaOlsayhxDye852f29v52W8Ol1Qh4+kwBe0ugAoCP8t2JeiVdcFTdEWw023urQ9iEqMPGQumilO8ysEIVnRpncA4dh1hX+iy+oEdN/igFgVIDTSRa++/8cxJD7sj2JKHaBIj3AThQGgqdknUUpQb3OoKCqyKgix1nw6pVCSRHWvwN7eD99//+r45cnp9z8MXh0MXp1sbR8fHz2OG4UA85Vz37N6ectaJlKIeo+40M+sqi+BcSI1oqEYMgZgRy7Ij5K8pmJCjiFRieR8pKhaYC02b5ufcDMtR2CWn8icisnmRG6OcjnanMitZGt3U6t0EzOdNi2x4EcykX9+vbPzsv96Z2+nc30wSKv/2PvBGVu+DWuCDuYEP6yuGespVSxLJrkc0TxIuoI92GXXIMC3YC34gsYCP7Fv0VrQSgZ0Jj8EjL3DXHBx+ZdKtO+R13+5oIL8oKhIuU5lZE7oWbUwAePB0+yXb9pKUKPKZ03zWzMT3MUYakv/xWb9DdoEOojw8Dn+u+r2LlJitaLh36rwDDsIJ6d17uKd+8wqRPczf7wdhsmP4YM7IUx+ZDIu5J5SpRaI/o7Z2rQKNIWEGDv2qMRkyDKs49aAAjNhMrwSp4F7SDqGRWkQEI6lUxCaK8RhO7Kzcy8BS+XiMlRfl0WR8yhj8AH13blZrCpp+tgz5+4oASmMYrQNGIw4QUyYqxUVo7+cy75LgkpbAeJhNOt6+VzePljirCa5osV4W8tcd513T0YqMyVHWOu5Y+Agpl1xLVe1PsdOMjy7eAcL1C0UHS0d6qq2uxvm0l1yTAXtSH70LOKeQ5wweVXIZlhefKtIMeEGipSLjOTUwB/dLtj/Jmu5FGuHpP9yJ9nf2j3YGfTIWk7N2iHZ3Uv2Bnuvtg7I/7Td4ysUntc/WJ7n8aUacY00kK/n02kRtU2OyURRUea0BmpqpmxheTxD7h4FvRzH9fWiKCCuXCUegP7EwqNknEupnF2jF8wSbWhuHF5OiulCY/UCEOt7wIfxlq+nAkYw8mAi44LQ0sgZXDfRfdIdejOS2kjRz9LWehVSG5qv6sSun0N3yE6b8FywRn4aNVwDqBLTQNuLKh0E7PGRr48IYGN2atCRVOQfZ+d15dEFJzgkpjnPWL7AC9frm4BMB7920/TV7mD3wRZ2xSZWsFohk3wPPX6KR/b/erxsrCvikm6cS5nkX0s2Yu39uxzr9MuLA75w728OGzPesL0gnZ0dvT2Knls6IXeRbh6pCYgUdPP7kgmpr464YvfCse/KX/UybvTRXVKunROmojpR13LADkhgeEZXoGOtNO8YHDh5sPSZyVlcOOuJ741awd+Q8W8CKQCPe8YcjHdctKVWNUGQ1ydH55a7HGHtlwo9AOeDa9++I1cWF+es7bxu2K0migX9HKrbZsCi+5qXerw2MMikttWjqHS303+qPrlTnbM7fYrVWWGjV3s7QgDnZs61ey5YumMkcLz3G6HmgIUb7N3Km2ttK8zXf35zsteD1OUNgoBGzAkuCTnKMj+ocYCKxHB518RoATWtVEpDPbL6EFEuod4O7yoHAs6/ZgVV1EjlWQqt36UvtKDXCEPaI1jfYEp3rva2tjfCBCsogurWjQtVtycND0cYQyVgd94EYwIlCkL5rTTGBMC+Y7AxOQVBqB90a9eg567/ojsuSQEpEHg8wLJmVbouDhEgWoKPfeEUdPLC5OjvKViPKOarN+WLjUeozt9CEv63kX//7aTefztZ9990wn1gqzKAV3m2Wn3yCaBfQNVtAv26ymPu7GOlUm2oiCoanB5fwLvJd577La3W1gbGhU6hnpM72q7RZlknqVCor8JsZozqUkHBhrggkp2vC5iup35OqcrmVLEeueHKlDQnM5pOuYDAZ5leYzySoVyAEmiZyn+WI6YEA8hXmUUY3A+A470zEfSLi7bvGuW/av13Z38e7F/tt7M50qJMSk0nDxEXoNRMdnV3EZtzpqyiDemqcOeEOthRXRgXQVBVYLFPQ3GZmt7HDd4+ruQGVraJxLyLlOZQeJZaac5Srlb2JpICD+EPSsxcQj+wL3vLy/PTG6ZcYdUaVL57XfdCEZIBjHSrpnpqHNdVPK6HKqAZ19eJYjRLmlgPnxvAYqSpQjo8lgR5MaHlhG0AhnC9bOkLOpkoNmnA0RFcE5rnMFS94aDPAnKRq1uYyjxnaRMO4f4kQATj1dLA9mmY+FbI8PV0LtSO5Dhiy/4W8YrXMq2rghPDU5bGx8s2sr6ul+ljoUWpyFtmvj97d1HT1KCn11yUtx1tV4OOegotgiboC1YuQSl79/by3cW7hy7ThMnkd+CcgWH+Ozho6hP9nTlpcPC/G0dNPNxv3Fljh/q7dNjYgT87bX5fThu7Zs+Om5U6bizJf0/Om2i837YDxw7039mJQxpmmBWt1vpPrq9Yoo0O75lxinWV9a3J3JfWHPqRDsHua8+kYqZUQnufAsjzzlJyTxfIl5+j83+gbhEjeR/pQGs0IRhC8zldaFLCKz0ozeWqhQan14xRwcUEitwKV4NU3HAlAQQxrhUfqlVjjo/CzBan+Q9HjBq4c4ddlOmwFXZSpvZgbd5gy+JFV5p9sFnTdFWbjLw5Oo6HEh6Gmq8SMQ09MiUw8vc/HJOXg91tuzS6nEyYNiw7JKc0nRKZGmbIC4cv3iMH/VEUeGr17Q0sCeE0AWcVmkvyS8jt+CeZsluasZTPaI7I/ppM+I33rcC6V8qiq5APHVONZcehvIe90A2bMJWQC1Tp+Y17EB2pzvfiSuKEFqeLYsqWXPrrv6wNBv3BoL93Cj93+ts7az3S+nA3Lql0t5/uyy/r2zv5BkRLOqAI4BgRt4i4xAfBb33hZieHgUHk15LmACQZ2ox0dLDoUpTonIuosvuV2i4FVlgWGVPELnHGtDMz1JfVSPt8xwF0heESNrE79oubiJYZh8AVKUuwatM8D/Xp7BZTY5o20DXclIG1fXHTUIMEBU2vWVfxrS9ABNf2N00GLlazFRRLGQT+emJ8gzRY5V4I9PgG6CB1MqYznq8qmeXdBcH+yAsvkyqWQaHbjI04FT0yVoyNdNYjczSIdkMz4dOd8ynzJywE+01CbrX8XHin1PFgA06ksyouN4bS1K7TG/kvetO5Y66ZEmxVxXZbc8Pew3RAtVZ07krxd85oN9lNBv2tre2+i8romtXTWot+T/smxpB2ZL5ro/y9i5o+6upr7RLfv+MzKRNG6h4pR6Uw5ad4C1Vz3slbVohYt/5BI6cfun59YW8o4uWKaOMTsjl5LkyV+xcZBEZK0gxUW6YApx54MW+AIfrHoYBznsu5bdkpjXXYefLCx2+xjUOSc1He9qwOBpQW/LbKZp+3auWc4ZDeXViNc31dMZIx9E+D8c2pry7uKefof2b12m32iVG1ICG8IiHnOaMaAK1JqcEIZ+9RWTCr6VpdB5LzsavT44uepWqhZCE1IzySA6grbNmt1cBUH3HlrhYpuHU2HsI6twbJ1m6y1ZpF90l4grr9iwL2Y0Mf+0EqcpzLMgveSe84xVwzCIlBMw3i/eX8mpGh2U5mLOPlbJjYDXgzq3Zo2zUa4l96YOCtfLUe9TfOcauMKKHFLmNKR9n64oG1DO4SPC9YKkWmK4ExVCD3EafN5d3Z3msPySqc30rsMgBgPnXoMswYQBxXNOEPdlY11Mi2MQsGZaXZJ07d/yZFE0ugdQ22Ey/Njgm9oTynoyXI/Uf5iClDTrnQhnXc30BPDL7+Vjb3agLzo4n/7mL0o7F//XD91sBWiXrvKAr8EILEwSGoXOh3fBeNwZiIjFMQKqRYzPhv0XiQ1OHPD1h3m4/JEGbFs6HdZfiHd4eg4TOVYoxr2iz1LTJ79woZWa1dbaIlG3IlvpL2NnSrCkPoHtjTmZu/SU57MZXK48BD4fUqHKxOpFolHstqu8mnZL4y4OgjpejCjhY2O/TsIyzAy+nmUUvfIg2/xDUfUUGvaDbjYq1H1hQrpLLi8pVtNPZH3Cfi3JhGytpPl5fn7pO7Is5/8Ok7AWnBvojVpwEoLKiDpcq9KqgZ5LNBzeFIkGWkVLmfu2K/lkw/InnNvziS2eJzbcTIJw5bhdjqGzGG528Mn8Aoulbw4ODl3UN3xbz+zeSnS+d4wm30SSr+xPJckrlUUQn6FjVXsAcuJVYjv2MnvLCTgPtmyqhV/LqNOFu7O8s3xsrEoPUj53pvSkKMptP62tSu81xOtA+aD22nOWfCYIaXBrxrqHoDlWYo2P+bfmieVdlqqMxitBYRUvS1oSKjKsNhIDGrUJHh3/vvcWT9s5OqqLeVC/7eP3YD5VLYb5cUxtjeYbt7+y/77ODVqL+1ne306e7efn93e39/a3fr5e4j4vz9As6YmcqVLWJtnbDriNDnilvRVkLqz1aynwxcUUpvO5uUPANw+znVobzKYdXA2mUwbGF2xay0Z5XFOSBGhlxJjDf7tWRqwcUkWavFf8hxNQy0mIXeIfivUCxF1z1LaenuFF+CB9Ilm1kcOF+/j0onK4JcOaP5gmTMOOcTIe9qDfkC8DO7z+JEAC5gkNvJIBl0bp0fTy975Pzdhf35wf6QF5fL98KKa5Guv+GuCkWwq1qO1Lxvo4MY0mZgYaHkRC0bbEQ1ugO92Qm8xe0LsLJWCWn888NjfKF/CUZiPMcJOZazgirv/JnFQ6ah0TmPytNEva2vaxI361r11rUpywu3C9zqQzeKUaOJrJC1ZlyDwjCBKtyOfXUzCz6jE7Y54Q+uIOXprdiYKbUyWK/3rrsq9jNmEp03kocDHeVyEsO0b3bMSRdSaPbVZS8cxkOFr3jwz9LX+T3oeLf45en5teUvN4vPE8DcZL41pu2G9eW4drTkX5Btu1Y7+DZ+8xjGXePSoVUnYH5xbu0IrQ01pV4ScP7QLY3+q2VLXz+D2PHyuPPdQTv9d7X+OhjvXX73LeePC7G1PnCobnk4a3z8KcCc0EwMmuOB6xVLpbLKA8RLYdEr/LXZO6nZBaGaHppUXLyoIHKEm8thiIy5YnOa5z2iZAn1h3NJ7fHKrdiqNmKxMRy123DUQmtTKjJwINMQUpVKIYJweuZeRxk3tEqJ5mKSRw1VhMAB+tY0E1oqCNsiuqCC2FltIGeIR+KjyjoJ0oEG8HDbDM05XZWNLWwj7BVDtqr1rKz4vY68IL+2tbuU220883XfEVwGCM2hKkiPyNK4XxTJZr+BUTIFg7MfiqCzZR5r9/JDOdPKTAIVPc9OmsSsHY6Kmhdv35x3nDP77+xkye37YNV6he6Vs3gd2fId1V233kzvNbcKb3JS54uvwwd3QoCctNA5wIxsb9hcTiZwc7J0SgXXM2c5hw/BHGNnE4HjgkGnQgSxjLVa3U+igrS6c+163pxaxQuyKTetMuL7j0zfdU+iXuhcTkJHIxZdqwCxRIZ2uPhY8t2wNhH/VkAyMtKFOQBGiZalsqyiNkMr9thJsCxu/7uhF4xGpSGKupgKMsQxfwdOKC5csMXp8YUj3yNwR6Ca69PWYm3Um21W6LcEh8qcoCsirVK7+cdKzhqhmqHVu0r4k/uU7Q8tnUWOEDKnWqyvGwSvQECGML4eySSsl9+VUWJjtyy4eUPVZi4nm+NSQKFgnVRH7s4TWjulteLZTxhQFExUdsYhDdcvUR3VOtDN7erYneQNedoRzzWlQKssrRLFbpiCPFoT1zXiGJ0jhYMem0jA5sEjAY1gbBKcKddvJhmuGB66hX27UioWsgTrXFGa+CQGPmA5lh8MmTLlxZoLZAP+q40YKkbOmF9hZFfDOVVi2CNDppT9D4cflVxD8yVWYKZUZBGKmPKky1bzJImRcT4gduwkDXvf0qLIuUvyDXWYSl0C44oPI3HFXwJgQU61z8HhghvuLbWhF5BfnOZFSVpqI2fLw66lmvgCsViuPRlJabRRtEi+97+1CImm2wQYXM67ck2XMjiX5XUX5WyLUSZDKC/svAleTXXbFMLKkSDOotxEf2kcsw4q7G7fOcVVpvQ3t86jZ76MuXThD/rA1wBWmtICKhTFlwhmg4G3KDX4XtVZ9yu2XWAx4Spccl7DVkv+RW/agBB+MUqRdmNCPFlRudpSuO7tAXP+iSb177HXeFzcoz5BupK7yLObmg/GjnnGNKTVQlSNT1P2uYTxE6FprOJIdJFzg8B0hpSFvVjAQFrkjBRUmVoENuYzKorORzBKuWZ9gAESNc58pMKuMJQNy6DFWJX2JHet9OJ9XZuGn2yvNaHEpVqGNqf0xmqeVlZZEG3vpZnMsHoQKI8Ua0NggC8TqQQpSioi2Bz4l1UuZvKG1Y9IzqiwBGoMuWkArJ1JKLPHMliVTKZXLibeXo8Z13SUs4xoaSmfUriuRwzcdHHS58jnVYBl0V0OihnFWaiNMbxCtrLkhF6wgmy9IoODw+39w60BondAtO+bBamLXp2FAQOEI9z/DzjBEsrH3HVGnUgxY4YCHkksMDkIkkgIRRFlxk3zmrjh1DUVIvk1Y+T9D8ea7O1u79rl3dna3+2ApcS3xjTlOTeLZBX2xfVo5q42H/EDaMmWzTjW0OhRmkqFGoCMZmr3mp3qEvQ9Kvw1XkHsVZYtkZHtne5NtL3zSdqt8K6NKGjF5z6a1u9NxI75waFo+x/cHAvFpXpYCa/HbY3GtvD9tg/GI7cEq5rkmhyQ7yqi/UeQ7JM6TwvlKe37Cu8Ndluw1AWeBVbvdlsDu/HV1pJwj512JoEjdxjI5x3HT566oOXc+9TV9GInzEGZUj2FrKfAiGJ1r0LWbnYc2kXKNe3bZycXG71Ys7OqWWvw7nRPpF0MZwzxXw6TO4duFUW4qryiaAerDRepifRRqzDam0cWqLlF2b+pLNAA11AOO4fSuQ2W8pWwCVYtw3/tTRI6rCM13GtzgKNjyc6IDAZfcVNEo+jcD6dB/2/k3teNsm9rH34S8j7kzNcAmtE7NJuVwomHaIKTN0w5UZbGmNAgJGI7McCyrtk7PVLAY+Ccfes+itc12wQaszL1TZwd9gBHUGW9WNWROkJNbMJvmMCKcPEonB2sUNLIVObOpOKNIGrEjaIqxhug2oHOuEAaMdEoy894qqRm6oangCBcGgRVs50tUGGpHtbXiyIyifH01569CdlIyuseMXMrYyo3mHkthZULorkpnTYxB/sYJj6LLDJcSUXcWKpydvY2y0LAJJa1CzaBzYxpQ87OiZwjhHYhldG9ODxqzhUL9QCjO/ozggGh7jDiuqZlcLGFtjU6Q8namXfBWQZ2enyx1n14KZ+1ttySMJRO7fgxISjrGIOCsSegIUCkFazUSNpzBmlPjWjXszEZIuExTmYIwsrQLgIXaN3znyuHytcjQ3+43VcoEvFqhXQ5W3LL7R+0COM4j1lcrTK8GFKB5Dg4XgTAT/pJk7NzVxECdx/VZM7y3DHL0Kw/rhWeY52PRhXqiZEy79OJkNrY29QHERvpQ5yrsz3O6znfrxlVgsyswElNV3lsu4lyPpmazUDMPs+gasYSofNw+u4/9Nvdn/7jzY97b/5r82B6pv5+/mu6+4+//jb4S2uJwtZZgXVn7cR35iUNfx0YRcdjniYfxXtfaJxlpLImHH4U5GNo9iP5zoddfBSEfOfiLvB3LkayFBn+IUsT/QX+YkFz99Kt/ytumXxHSgGH4aP4KH6eMkFmtCgsU4AbSXv3kL01nVY2k4IbqTwWMbs1vbjJDr9RxRoBX1oTgIe1VLnhbN5zxV2CVUSTj2t+wmtx01KRj2tu9mvJneP1pJaKFEzxGTNMtcYft+2ncvf4awNvLmvoqEaPzsnhMq31yMe1sGjwV1i0NTdbv2wRIZKPorIc115xdip7b0KvYUQEuqCKM1fLgWu0MMcjNTKAwzakKK8BmrmEJdQgt7hwnNBJggZte0nXmsVhVjMJndd6dIeioy8PVBg36lvzhstoEJdVIn+Uth/FrttPzy7ONZEqbvJv52/DFR9ABZK1bsMx0LPFXsZSzanKWHb1peAOz859fjh6dyOfQ/SVMyEXSt52x5duvdpOtpKtpO1c4VTQ1RZEBgzSc3/hvEVjxAt/Gczn88SOKZFqsomyoRVT9Ka/ovo42PYHye3UzPJaNAwhF+56ArEpd/Wn/ZvabRaa84lwFyMI5G+Z+SGXc0y0gd9cXl6tbcjRQbXCJ1J0za1zQfbbCyHEg5bgbmPs24BvJpiKw05olrkb3iGb2BPkxaCbnAr3cG2mtXMKkYKCqZndn397ffQWd+avfS76v+IHhmLACtfE4VUm5Ci3Imudgm5cPqLBdp9wtK/D7y70AeYQja0RXWJlllqzMB7NRObCcYCvwMIGX8jBYDvZ+pUwkdJCl7mT/q0204j2qzWMKvs/GLvukZ+5YnpK1XWyUVuE+4Sa2QklbrYrOnWwLu2As1rYYifneHAcWTS7FVp63jmzBU50WVjZnVN9ZODgqmEJUPFGNCOsgAc5wE4lqgDh/aHumuqPkP3zMx/z1nSWIiHeR8HrUuQ8/OFjVDn3bocyV33Toc75Lyt7gFPslit02+2ob39NrEBXWH/90rPsShdD7sduE9CUeiSH6+RfNL3uRUF+wdLybVoQooT4KCPHj34VpL1wvCBAflYSD1qVAC+GZpGk/p/YX/1oO2m/onxOF1ZyKbOiR0xa9Agvbvb7PJ0VPcJMmmx8myti0o4FWRGalwvBf3dxRt7IjOWoZM1j1C1/DF5b6iaWprtI2ci6V2iW9kjBZ0Dob5PMduAtOv9R7/w/9m0fQoNce+4d57l4V//07rKSUXx/s7YkeGdogAPu2R1Xom9Gqg5Df8ZAVfVB4JjP1fPtY+whBoZ/ssV+Xb1xphR75yLCcOwRiVHyQlCjryaJjUK2OWAQuamCBh+g6FrJZkYSVYr7E4BoOTa2u8SXJGhWt/ReNd0jczYCxRhMH1wYVQL2Ycha3ywUzBfa9bDtXgeobEWuYVQKXLPxkKIeIfIllxqUn1bTlqpH529Cfl0gbLRfI18TxRT6Ja4mdyf5/Bs+JlSEdEOgOs5Th32hfZoA7g1dKTx30Btm4VrFiDvF04S8cVFqv5asxIbJ6eVrKI4qBWwhb04ulIQ6ApWdLjQT6jcrhsYrCaG5Vkr09NAOMOAR/jFWT8T6XLXan3UHIU+mEvXXKr0LvFFRnhKaNyxpAMWupk5arokbAqqxxM1AiBrVmo8XPs/OW40JucB8NapmNXNmrW3vlWrqs43sNe/NhBy2Urdz2EiEJGv/xdCzbkAPvSwc/H4gUvKczfbFs9laNP63T29rUeSPlu/WMdk/qrgZT+8PK3V2TLi7mNjTmJrcreHriXk3VbCn3jHzu+4MyCCs3NNUMYgSrt9xPWSgZ86z1SOnzt1Tvz9P3vyjR3563yOv2cQ+ZZXuLqKfl6Ocp1fYHDMPJf5zqdrnUrXPpWqfS9U+l6p9LlX7XKr2uVRtazrPpWqfS9U+nA7NSrVtvaHyqD+RFcvbeFZixgoGpT+KHcvXDnw2ZD0lLFOLyP/2lqw2Sf7Ipiw/2z+qLas2v38LY5af8Ve0ZnGRylkcHfh4a1YFeEWx5cYt5zhoy5IF1qtaw/ewZJ28+ceDqf35kchVpHGFBrtcWllRDfZa+fX2qMJ7z+XYO/bRE5RjfxpbxXEFmnTnGvvkJHgQls1l6cVpiuHNWlKix8SNkgVCw3xchQwHD3/wulMEI2F5hZSKCClSTajgvzXV8bMxETLGgYKEDcYylsXFLd24cjY2hM0Ks0SJ3rqCeP+LH1sL9FzU+Y+AIf5c1Pm5qHNFvOeizs9FnZ+LOj8XdX7Sos6FklmZPmGxjpYh2PW4RMDrGLrejopGBYQZpjjNV5vG6I2ornNnIm2rQysrlD2tl7eo1NcpQ48bRO6C1mv1n7qKpFAWteeFedegT5esWloUTCdd4LA+8VUNK+4w9AIzIMVmGv5TwH9AcIVfZJ4zwJNFq679rQqOXYIo0zJeVmUaapAdT0fsv0FH99+0F4sZFabD9bKUZ3zxIYftWrv7K9DLdMq0gXQy14KPbm9/c48yli70OEoZVQwNJT5jNhRXr/Vd8d0ZFXSCUeSpIWVRSSsPAcfhV6vlykfnZ4ERj5g9agGjnSq1IF4Ao00QirBVbrZGzNCth94/aV5qs7R27ZPXSPbdP3bYpVpZ4fX3r/2g7WL55XHb7UvMZbU77jJWAj9vMSB8oqj7LZ56A0F/ViBErlCdDUjZpNeAYpHTtFupvS5HrI/yz4MFtshEsyqJIeqS0PEYARedtRkByF6MpUKtsm+YoMJ0cWb8p5kpiyW6joMRfyhNPI/+WlzE9+9YJ2IMx6y/NknDtOkXMuunWTp/sMAe5rpC7e/SiWcPm6fDJHnoBFc4r1hG8NwHZVEETLDHVAlmmO4RIWc0A3NVLstsLEuRqUX3Lq5eu8/c7zjYQZRpffNJnMG4NZ+UxYSyvApkalRr4zr4AfwvlbOCCm+DlcrFqtXk8UYcVww8qEMZrinLC4BnpEpRgULRmOeWyNAOlP/2pmdAfAa1WMCD3nwdhlHN5zGFVFbmgG0X7sfINdYwrjcH+O9o8Iv3aGUArkwTjWMQLAcX8c35qepw73z5nYAP3L3tm3arh4vtfyjfxbPj4kkdF39Ar8W/Iwd7IpfFH9Bf8eyseHZWfK6z4nfqqYgRqqrSN06qOa99+AlhppKtl8syIEtrQ3Os6oKAE77vCHDdVJVtgKNDPGyrMf9iFd+OLC66BjX/rd4u5GWExt1gsFWH/1C1BoHyUIQyrQnGDzCWqnTKDUtNqVbFYNya1bru3AW3B/tX+200nVHJ82zFFt71I3ceO9cZWJwdVdMmF7ZSxSr8TgqfRDU6A6Ck5ZTckIufjjA7SyBYCwMkW9/EEoTq8e74JTt4lWX7W6PBq4OD0dY2Y4PBYPTq4NX+/sH+y5dbgzR7KPNIpyy91uWq7tRj112LkH72oBfeMBVKQnXjbR6MdrZfZfTVwasdtrM7ePUqfZkd0GwvHb1KX+22XYrRIFY005N6Jh4Auja5TTSjdwUToRiFkhNFZ+Dby6mYlGDLlm4ragjs31Qs53SUs002HvOUM1EX5gKmTlvnR5Jf6VSuTPY4Exksp5iQqZzHxIDCUWEXuEzxUjPVh9TAHpnkckTzTprhV8smyB5i28ioWSrOXlpmDCCknWNuUzjnKRN6ZXLda+zO1eKtLO/xaD2TifiTFQepFXyUcbcX0B6lI2wxNtcoOSMX5yd/J76711wbLLAQyUta81HOKvxfXWS3gP3rmtSbG9387aig6ZSFxreT9hleoRnbX2WNLqudJ9vKyerKEZ9TM41KW/h15p2bMi7tW2q1Ccdq85jlOVWbE7m5lWxtJ682W/NRDOrdrMx99JOc2amgPTR0Hjv4gtQGMjzXlRDGxzXed3cpsVCnQFreajfnQ+9MK9o9gCqPKjXmd6DtC/BVF4bp7rtwe3unHfuzSsXSO0LaMhAEZjvdysvm8ZbFEtqLgvV8wXAzpfVH0JVbOcvAshSA4g6JKmY9khXXkx4ZKTbvEWE/mLBZj4gSPv4XVd08RxUP9jOuVjr1m6Dda6VRwfGtK1RNXeqU/MRodi9Iw05t6mfUtcm5VMYeK3J6y9ISf31xfroRCkT+LtSU4/MPtW6JoWrCTHBIQEXdTrVlf/fB0nXNafTUM/MAO77bWkQTVoN3lRAyQg08xXMGRd67DXFQskmODTmWqpCq6V2/FwlWL3kHMmRtEfwRVDinTUSRe8za9rNiVTZMu6GrPmLK+8lO8mp/MEi2Xu5u7T107nxWTKlelTAU1UwChXIGpZGw6NH5qauvfST8qEi/bwUMfIzUxtnv+1wdH0Y05mLCVKG4MGTEBRRcgdAOQseGWTEFSYk2A6mIhDsslRnrw5xD24iW7s0LGssgyzQtlbJaDwrtCJycTsErDGWVjKLBPAGjR6vpJ2swzefzZMwVYwsGhZhGuZxsmqli1PQVw3r0m9uDrd3NwdamUTS95mLSn9Hcyld9JE7fdsjFJJmaWd59gQ7S/YPBTrrLXm1vb9lfspTuvdrfoTTb2c+y8UN3jq8jfQXHZ9Vp0JbIn8sxL86Pzt5eJqd/P33o3FcbrB0m3BWx/YiJr4W74uPt0amXGOD3poN67T6UiaiSVlgZXqCpffipoI97WYd9R90hG5YthLANqNMPJaUc4m2tPawA6ZsjPNuMtrGrZlWrjw7e+KHvvuDZkMixYYJoQxfa+yuwK8KNZvmY0FCsCILAC47syj6INhFf6ArcsTjc2OfwEPlssioEjPUjpejCFfQB4lH1f9j7++Y2ciRxEP5/PgVCE/FYmh9VIvUuP9G3IUvytG5kWWPK3bs9PUGBVSCJURGoBlCS2HcXcV/jvt59kgskXgrFKkosSqZpW97dXpGsAjITiURmIl+GULldtjQxhPJ3ORBX2Jc8zRUxPUGD6ykIv/MKaiAqP+CJFu4m1sZQLBNca4FQhIQqelcqdzIz1xbs6D5lW1KO1lpobTPV/80lEfr/d9qR/p/Ofl2yraZnD4opLW5ATnl/CBsqf/w5PtLzQIDRpL4FfnHQuVxZVzjf9ljTVNCf+nl8SxTCDKcTSSXiDI34vR9yrNVMv07onghSCA7FzboF2wt9gJPKvzA2axJEWlDrKjQKjMxlRmPKc+m7rtYvywKqeUJ6kg4ZhnsK8kDl3G1S+pynBLNZa/LO/GwuVjOwMegAYeRnCzsp1fKYEjl580yM9F+UDZfYvVJLssBl6LQoDUiJOauZ3u5R13LS7PCgZPkYs3yAwV4zefGFN8ikiYRN0d2lLjV+zzvbm+44y1KC/vaxC2WF6tko5uNIz0uihyyOILHlucugsMqXJ0Ofus6KiVDmboUgA1r9cjixkHLT+ysWk0zxocDZiMaICMGFLIRxOOodTmkSFhXUdrXIpXLzaZ31jqCcFVXw6cDVUIBXi1dcDHwxvh/2HkuUM7i/IsmMZtWfPn381Pt8ef3pc/f67LT36ePH6+cuZw61uJZVA65rpiupZxBgBbUkxBez2qewVgSPlyxI9JQvKU1gPLhbhGQvuH4t4gCMFhwVwqM4j5oLkbN//vzfvx1+ODz+5blk13ug0T3WEyfTm67igkjb+ajYkzX7TNuhdKr6JE2MIl+8Pus9d7BrwwGEuLZyMUvAce+HLMXeQK23Um+M/gS6E7uWofr8J+nEXFmbGwEjUOr1tJc4Q0EgvSD56zUDCCGnQ6pwWtYRzD24NsGGmDKpSjouOCQmptMtU2WXQFW84tIazSE7F6XfeIxZ0kvplywGtZSox/LKvc/T1GGHNHaGKUG/1dKmEEjTobHOUPFDW4NlylAx2wOnaaEdB2sKSboVtfmZpkxox6BN6BYukDdfmi69yYdY4ikxO6eg7mggUwURjegyBwa0KoKN1g8SOkw0hmkqJ8Mk6UKzGaB7KE5UimGEi1mooewAMcHBsBU/fz4/baHuRI45c44M9PfP56eyFSpMOGgEP9abWaOaTvyRZuqx+8Y8cJpVsT7hTCqRxyC0sfUNpBM7XEg5qLak2ZszlAktamMIORlTRYeh1nV1fooEySUp9Z4PzlrsqBl7O55Dtjkdax6HZtbTaSzIlQvV1ONSzRDp8Xa8u7eXHA2OjnYO9hqHOhV77RuXTE9iPJ3GPOUqCfdIyVVSQ/NQRtRQlM5qTbCYM+MaRCJVRsct+zSKQuLArIqIsWs7AdmWtR0zi/Bi3Nfmtj1ufX2EYjInO2zmJsTClL2PyEj7GQEsnZ2Dpgypt3g0TvaWJDA/nO6ZKesBkaNSnvqXhKT783HnCVC29/aXB8z23v4T4Ox1tpcHzl5n+1FwZEJITRnILwNO9/Ts7GoKnAYZ6D+YqH3jjnSTAFXS3/QJKFFsw11NjKc17AWSdEzTWYEqdbI3w0ILvVcH/TSxFnPQz3tLV1D91Y2/Cm58uyDfnze/HrFXp/7XcerPWI1X3/437dufsao/hou/HvlXT/9yPP0zqP/q8F+yw79+HV79/ouS8dX9/4O6/y0HvN4CvN4CrPQtgOPT7+Uy4Mt6+psS9fU+4Bn3AZaKX/1aYAFwv+7lwWIAf+UrhsWA/soXEYsA/a1cV1igv4NbiyVfSTSjb0ai7zzrs0D0Nf8zIMaPmQla4P8j54QWVHjNDn3NDl0sO7TgoR86T9RT4TVj9CkaDRu5oRaq03JeeE8sLSCtMoiSsN53Z4X3iZ5HIsUXVVCzOqxqr6UWqzzjU1frK95u724vCngt5C9dN0dP5aj9BmWz0WjclcWiAVZ/AzwerS02IqbYY8gi1qtcH0yw3e7sb7b3Nrd3rtuHb9t7b3d2o8O9nd8WddmD3E+ateJeaGWuYSJ0fvrSbGUxWOIxYFGZWeTaQLTZuHm4Q4iq78st6U1QwGzKMae5Hr5vGS+3sUl9R14s/b4wpZ9OMDO1VPsEJXQAhcJUgUfQ9xdh1Bf8XkJXNwUHClUWCOccvSd9U3UMlC2mUlPUd+p2rMnq5ZnGYPHdVPZnkJizpHyCjLA+RQhDeVZfZHdne1H9/J4Lrev1EipIrLj4gpbr8rlQM5tFEHkEpyPu6gi6NeJjsoXTBdq2/ADOjlcvh6HCD+re+MH9Gq8OjVeHxsIOjR/ck/HqwniEON+K78IDvDpeCQ/SqvobfCHhFfckeE18BX0EU7CtsvXvQf0O7Hq0aELct2n6O8qtllHvoPrezPWmzPViFn1R9H5IpfJ0tPUmP5W/naNhuikQCUq1K57tBnHNtTiTzctlQ5FtKAW/LHPjo1VQTQF6dC+oUsSWuexjSfZ3EWExT6Djkx/lPRcecVFFvGh01CXqF63jnz1A/PMnMvxnTsTEftcqZw9AKUuZmb3DixDdjFNm0wdu0qynv7uJfI4Iz6xF0c+V0++KMftEOdPmjgjcpylVE4ClCBUsAuq1hPl09vfeu/PL40//YzAniTNTao2G3/75Lj8+aR//8s9318fHx8fw2fz7qalSCMtvTtB5kxuftfgnJsfAND/RSw9tv2B+GD60zK48kbBEWk5DsnDdm7Bmdv0cc0TAMpKyYXBC2uc9A8GUaF0vQPe3FizE2X9fHV+e9rq/bRheCQM8PQw06MzBGXENysyU5I+csJhA9LSdEJhbj/7h88X1OcwFY7vh0jRsEneHBTTiQSmk8JphWT4mgsaAa8HteszTXz9+OjXMfvb33j/1pxLoAWcGjOez8RIS0zFOkSA25dQY4+skGqKbtc7azYxw1Df/Wjt5+7tQ+HdBkp5S2e99yn4fT3CWReSBLJAKDcxY32bi5XPkFGYJFkmZF8yBb6WPS4iRddgblmmK4YjeLQO5435fkDvTNhosUuem1fPXHl8//+PiQ1NkbkmNdvDiuPxM78imqTd8Z6PQ+UCPWH8Odz++v/71+NPZ74Ul7Y6Ny+vfT4xe9ovx8f1+PtbK2nvqG1Boxv8IE8vf7ynTQGtebmxq13bueXHSQAqRnivMENJL3NLDgkSAc2TWgv/+bGKVNK0awv1+Svr5cFjKOZ2vK8oU3F+KhJeBvwbmdPpILXM1waZQAEHeTut/4ZdP1Bv3tRkkUVr9GBObTzrAsVYusCIoo3fcZOMInrMEYZRREmvU3KDQTMV+gOQveAAOqTD32zpwpTYcIAeTTVCWYv2k6R9/dtK12RDoOgTBDm1coxoSK3PGLdN/vjg9+QCy0mAK27PVnN1UBApZYdPbLH2GbiwtoxuPybEW0rEgymdRaQqdXyGcJALcTc437DzT0NJsxKVqId6XRNwR0XIpWcUCKJv40UJxSglTLeQe1buKEaWNhGjAxT0WCUl6NIvQ+cA04c8yYhPvzq98nXleQE+zm5ap+24aEzFLNKAYRkN6R5hGQQl6R3GaTlqIcTTGoFaG7dGogskweMD7k6JSRzDV287RdtSOtqPO3s0C1dqXeA9xnKbmjMJyRKRhD840oYRjOKsRmkRIty2g6W5ZEuXSmOeQ813Q1o7sa+9ThiRVub1RMO3PJjx/IzSbyFwQyMIrjewARDgdckHVaKz5bd2kJRNBBhze0gynRTAcvh6IjcbxWZC0tkT66/n0zLK4i9FfBRl99Qtjm2eVSBW+Y44ngt7/8/RStlDCx5gywFHvTy5updU67Vd6I6QUy3KDsvl6xTRJDCk9XKGGPRfOr2qRrnp0ZOlkWMZegQRbs2CPQTjPMZX75XNnVPHNoweUfs61tcCiuPtzaengfLOpmyajlE286EXckQwPtV2owbDJ+i63FeGUCBVwJOOmURggWRiMroGbniLIs7WjmatBZ/4YSzEA3DLoWyfaHVDJmEq4Dta2gOCp79guW+5RDRhskvPT7tb5Vbf4YUAFucdpqnmc9N2QQbma4IFcpDb7WrYQYQl4IFBCFIlNTRamTRV9MkqC1s9OP23Ybtk+v5eoeJF2HLka8WWx7SU0BeViiBn9056vXKBMkjzhbOJ7+BqgQArAX1o4cxQLgsulLFCxjo7rPNfAAVHZB6H12lVYbF5wkSxgqtr29suKUDku+ukbzjG6qh3SIG9TzE26vD0CHXlKNNNHYcFYLl19NqmOlSLjTNuS54GieEHwbWMDf+kBLdfg4KjEsgDLWFZxdJpNgHcpj2+RIH/kRCpQVrO8n9IYnV52TRL6z9fXV120ha4vulA3gcc8bdx1f2kVDo4N/uenRjRS6RL376ka2fZA0MvZSGsjmgN1ucRNXizXMl5jZuu0GwdRL7c5cmgxpjP6JM+WSCXSmURwbdHhhDzRY9Z2Mw67GM9JnqXeY5JSBATQAbywrhTN/Hvu4uPJP3qnl92e3mC964tuU7yX3W74zadSi2HFtQ36eHm1kE/8sLUnmP9Vk1gPr40YoyNYv7epTfXmjUQJj/OiHEl5NrBS9a5/86bgRcZVwX0tbTfFwbUoRillt4CPCZMyAKbmptOQoO9Msr+E9DSWPhGq3oHsYq0Ii+7pLc1IQjF09taftp619FqLJMsKArqc4nhJVAtlPKXxpGV0MKPlmLgOpzlo6xMkRmN9xlSnGJNxn4h6H6j1bfeu7FHUe280y6Z0zPMVPZPAFcaFjy4q0RCOK1mcV8aeDA4pSuRcx1RVWNcfWZ122/xfU/ouN8T1euT7PqMtJMgdldMqUZ9oqgDvgTPKFnetRzuaC18fmQRrUTYxu+F3jxqZx/ZZzRgJGVBmbgXNhR/4C/VvDGFvfMWcMbucA2/gGJMRCTLEArzlkoB5J1vB84Zf+tTc/xv5PUj5PVzpiqSwON9zga5PruyoLcOjHkwDW0zoXRENRxlVFKeo+z+X0I6cqHW5YX+0g+oBC1jM3Z/hXa9YTs9kBXI6qdDDkVufy5YuEEiL7eDgCLZ2JMKxyk0ZJ0ls2UMxRmt+vDUtj+BUDYZ1ULApwKWph2h/tla2PSz0qaEwTWVxONkRDShQp48N3QIXU4R4WM9TtzSB8T8AFnbEoHQdGPH/yZlhCrj/NM5d+3bdYAVpGVeVIQcg1vUymmjlaZfEiRl+y6FQvmI1nkicJEiSMWaKxubG8QHOdMwQeTChzK3SQUEleC8Heaofu6MaXfonKYIXNKJEQF/Swr3p3NPCzzHAqbdRgLa4OJyMf9refEtF0xQR4xE1RerAswI+icBXDgQb0DT1cgtnmeCZoFiRoN5lA+eEceIvS4GD3WCOWLtg/hYBcPOCZ9ynw5znMp0YLod3/LBwnS99LZSUSqVX8/yqhbBzfYKnP2f0AUmu+SdC6H8KiuP0Hk+kuTcpNCq9t/G9g8nth5vIfnFjyFjWFZnW5ooIhiR3pTThRiKi2Y0G5SYyYN20UEIyApcviFv9BPGg8iLVR3NNNBuWEcu1QtJgrR4LaLM1+MyYCKcp91BbBxFnfMxzaUWGWYfi69LRbaWKHWz9uHu5Ual8B4kJOB4VXj1DXhPhTWac/Hud/aM6WoQuru+h/A9qGEb3McB/dljr3zkfpgRdXJxUaDgjIq1J9Pf0EOUS7BB7BvXaoIVycM5YFjNHQ/2yH+5WXVuwgeaE+FmBKwZKM1/1EmJIeBRTNVlWrekTqiazV/gDZ0oQnNaDyZmijLBZBf5eHNbre76Zmug8KMjnj2MX7APQvJGz8bk8bqrilxFd0qJclgp/28nrEeJCjdAxhJbhGcDnTIlJj0q+rHU6MVOi8+5HWKhayE+OHwV3WexvQZ3JMSeY4aSesnCm1Zp/tWAOCe+Bx2cWLBecDanKE6OYpVjBh/rbj/8DraWcrb1Fmwc70X5n93Cn3UJrKVZrb9HuXrTX3jvqHKL/q3rQa8CX6FF881kSsekUrylPPkaOhC2EjY/LqOF8gIYCszzFImwtoEZkgmKooKvtjlJBW6sgqbIHkwqjUseEmZs5yOtKuYnH7BNRlAx1tk1x5BjwUpSNJpLqP4yHvIViJzPDaNdLrjS99IPGBAOLRWs0Y9B8hoQ7bOvdaX0uFWebSVy7ZhmXCqfL2sFvrmA6I2axlDym5aBTj0qpOHyuFe3CZrAhRD7+aYwn3it5y/g9g8BgpFEz1VwF+u38CpVw1FsBFPI7LCboniZa54Mj30oKuKo2f9bT9Wi3vdvY6a5JLsiQcrZMwfkJZnxKbm7+s6pvBfAuSXJaWGcKzn/mpE/qeVnbVX/yunrwL68yuBw4PZ+/9vFSx4Vhnx9fHgfPzUTKHrRbx2IIagfeepcTxmXvmArS/MKwJtSllgKzw1yKSDmHnNWC18+v7nb1jjq/utvfqOqZYxwvQ458OD6pB3DqSoRxe91htH+zwz+9P0EH7d1tKMWeD4dEKpK8RWfazOOxIgqtW2dzCx1u9mlxsmrbYcO077Aqor1gv+foX3mWERFjSf6NRuQBu/h56Lsg0ZDeOc9yOYjVgm8mNhkNOYOOLFrSKzIkIkLdPI6JlPTOPmgcD5JkWLh+FoUyMZpkIzLjNGi3N9vtzb0z+O/O5vZOZQUZVtELBUu9uRaYSetmg2zf0C3Ux/owuzy+9t5WW/yaWtu6OKA5ygS906L/9MNvG8ESlw9GOEZSjhPUxylmMRzNQTANF0jwXJ/YNa4KjXfGG2XJLpR5GhIFaiWsNlmMH3NBm3sqgRlGWti6rkm7rl2uF0wFt8sTipdpGEyeCBEk6c2y9b9cQ6MRHY6IVAEQjp4GlhYgmGUk8Wjkfeci8CO/L7JZW0GuFAxn/ZJa41obcB7Z56KYj9e0IFwLv5jum2SikWyEdUJM4Xyo/0xiKrXGBayJjS80pbc2p9xE0ch8MKAPfkR4Zn2kVPZ2a8s8Yp6IuBhuROjaxDgrblTFBzr216P9CZJ0nKUTpPBtuN5wamOpQICnuE9SabRCxhXEn5qWExr764tT6c/1tZhH+e1avYgNKFLhFk/+ZXKJnxQ2jDeSBrmWEH/kODW9SILoWxf3GBgtRdyriSslDzHJjHEFUY7wmgl4KbOQ3RYRQudMa+VYKBpcxKAKBCCQbNMi/X/2dxsb6S05MLny1NYViTErbmJQmd9aAQVizhSmTFYR6pOU39ezf/1eKe+nkLZr9/f3EcFSReOJHcEwjNkxWKq1QpCc2/ZMZpQRLrqVGFxNvqCbptAt12Te345k3u+UNmWrxNwFeKWuFJYKwRhrLbMXGUdKYJrqrZQRQfmM5k0aiaZ6qeJZD1D6CpKSDAYEunxpKCwTWcqsk+uL042WMSG9/VisiR/XiJuWu8QFwaHZ2fFRsIGiqlCdntcPGxQT0CsIPPJtS1OQpLMEabES84tU+K3CT7kkIlouK4Ue1KIOgA+5DyJwEB/MOmIxQxenx1dazB0bSpz6oUIeqikOoTEmY0zTJSH8WWMFEzpzqz6/IdKS+AtXlVrJGy1NoDeyOIjA8fdEyGbaJ0KhM8qkIgHrlugJ1+Arw9wmnmop3G0QX1p82eymbjaGzIaYwVXxlsvymLEJDOxLdIOHK2YmrwdsmWUDLUVBHkJKHDhShUk9LAW8mrxGIzgZwoyzyZj+GcBjSO0/fjYNhekA3QBWNDFRCvBBY3vjFZuYs4FZ0+kgW5bU6IraTJ7FkHNXG3tZNrSrCiDUA/blHLIrKWm7I22NM9syKOVDyuqJFIhaDKK2nnyCp0srbnPsEpyB2WFmdzMF3mGLx6NpSbe0jxnu4WRM2VoLrQkCFgcb9vSgc+YqhVGXRZHhIOyy+PKJ7HPixqgE8anwN5OuBd6eIg8iwcp5K++xRDFPUxJD9Tj77fWISD8w5OROeI4GlCVmA3txkvKhtHLEt4F0c0OdAxPXukCMGclGZEwETpfYYfTMzVkRBFR6tNbpAGrLkAcqldyo9KpOYMOB98+ECUrXBVMQqNInTYvRGzsgiNGEE6l19Xr1+xDvDvba7UGFSEuRjTWNV31sMmMmWtdg4mxpRyoqobSmoDJYKT4w1QsYT4i9uS2RooiK8+XhgMHAmElItTm4t6orXVNDYGyZqDG+JRJRhTIuJe2bGnGenwvzTPO1ZuAxUYLGhsehotAUl5drAOgNBg6WOE+xAHj9kGRMlesgPJ09csmVDeGkplgBI7YzOiHFC9Ls4xIY4PvhJbIXHoggWNTksBp1Cit0o9+zZ7Y+wuGjpj4oxXiG0yHZOSB7pD8gbUz2492jg+2kT44G7c7BLu7s7xz0+4fbuweD/QqfLunusqRBOyY0sbeBlAMqTt9T1bwIfULtToZzAypAWD7CacrvDVskVCpB+3mYA2vHsEnOIocUcO9XgvIBZb3M+L1cRLRUGCpVwV1EsXOYd5cF4J+bb2MsAYOzFEtFY1teobS7nIoWeqCM0z+XKggRLRwo7whWsm4Q44awxxy0Es58OT7/qF7Qm0KZNOVCBnrDGB9n0Ih5hpMrxGXTbsUqc/GELDX2xXEZ9qwCIEzJpYBD1D03ssuzmB7BveykqDN19G+wrYPks7AMJoRsQGCtqWvRChbHkcKL0SJ0pe/aSvtB7bHkIXM1Ttxo8/HYlAgPQKhy2hQA+lnDC0E2UZmBLW9GGgQ9vasHUtrhnEj25k2hZ0IRchtkB15yQM7P1prymnPhgLRVG8Jy6YV3jcNOp2yYUznyq1ZsVtjq+nxBeVZSGey5yKUGFYWmjy1SaOnCiHR3jV5UFMNPSacy1xSCx3HPBto00sLT2CI1xsykk0gyQ91wc2627b9OVaJLVa5Q/MUC+UyxKzPfFA2qdtmSitSB+u0yKRufNfDiVEF+4+yo0a1LOog//UuGgsEomOTMLeT5wAzChR8DCzIF3fRuniG+751WdlOSyjdzSO7KMs3Mr3v5lfql3DbCLZRPyinZP9XVKuS44ijl/FabjdjWMSEKcZZOpu2foFOFPyHqqbQTbUe7ZbsQMnimzMLwu0etQvOks9tcoZdKUheSBO4JjVR0eVs2qWnLBBxEdZagZp4gy0ozDy4nfrVsvEKY2gmJO1bAFtcVDqoSEGESXFEULUQqyCR7IocsjOmwiWQFTrNSpYJZYs4kTeAWUtNMq2IpZSSsGGvygeyofZdkBR5oVsZbzprQkaFMTMcAYU7geeCjMHdlfmxnmdkrWhdhbrLcAN4woRPcH6Y6V/1zjgoeSxPa6cn9bWWMWbq/Zoy9Zoy9ZozZ9fneM8bMnneVwwtxu4JpYwbU17Sx5rC+po1VEXpNG3tNG3tNG3tNG3tNG3tNG3tNG6tA+QOmjRn9coXTxgDA17SxlU4bs1z0RGqUPiHAl1Qc0dxnTdWmRwV1qZASGDynbPhNppDNJFH0TBp9Aylkzcztr5xHZuXNNAwrl0cWOgZe88he88he88he88he88he88he88he88gaI/yaR/aaR/aaR/aaR/aaR1ai3Gse2Wse2TedR6ZGgvhWiDZe8Dr87rF4wTXbw15v7BRLSQcTl2iCoVMm9HfDccxNUX5oNWJmRAo/cMbHk9/twL97BVAT4MP59aczdHx9/f87+cfvD8dnaCDwmEBvzt9ZJaRQyw+NewmSYmALh4mQ89YeFb6RnPGvnZ92W+jy7+9/bUHLtQ0XU45RzMdjLf8tyFExNNwHAEKRwrGicfQ3gMi3cg2b5Y3ocGQ1f98shDvzVo9RjGsg+n2NjjMcq9/XNqLSVCQegZyI/haSoTIpBG0Vg95SBu4fUORxPIJmHL7DGNxZKhPGauZpwYLFMR9nKZXmom7IcWqgK8b9fS3oa8e0oNWGqolb1aCv/SXcPvNE+/nV/grHp+VPD4IPsR7kAuJRfcc2c7Hu+K0k0WAgYAh4xi+YT3yDPespHaH3fjo7Hq0EAyBn8tmg/8Rk0EBvEzb0XQMR0fahaa+vEGVDIhUIF+PkJUpwmRnDK50CGg+HBlXX7qBGAIU7s2rYmz2wNKVtTW8KanyahtolfnbE/R/bkzeXBOGKbPndj/67HaVVMsXROnmIfFMjrBSOb6MxVYJAUyPzity6Pm6329tbaGOtjmzm11kEW6KmuFbidZeCMC/xQlpVZPTziVdPu2pX8inyLbsjGLCdnxRafK4QEcPh6wk670hVevuD56tscS9Fn7vL3UDNyOzeklvXnfbe0Qxuhd8eodwP6BtZK2XINl7FcOnCnfIlV/GEj8fYVivoGkzY0ISAZ4KEya7VFV4RcTQ3nUP6VjfOl6Xz/O8/QnCZ97+WZAJ/nxFPIRTPPQXCsZ5H9na785igitrN+7LOIPx3INhmS62Gi/uo4FrG4l7xeyK6I5KmL7S6qyHU5l6GkPT1CsFSlqHZGI0cN77Hm/Pa+Haqj7lsrMfGVYoAj8z1RbfUmbDkXxnwOJfO+x22bHVdCxFVkqQDOCkpU4Qp6KyYThC+4xRa8G8mJFMj33WyMIINEA/RXrvQmGIibCoi5EMSb4bO7z6IaTZqlH/2rAQciBxClCVgsttYPwOCYdEkF/5rm40ekLtWNF90e2cnpz+f9T51j3u/nl//3Ds+6/Y624e9k3cnve7Px9t7+003ti3NHdB3SRS6OvuwSVjME5IgqTBLNnHKGSmtNIfaFL7ZvYUV7rtLohtcViZ7d5ybtpab5CFOcxMjOUA3VTR78QhTdoMkZbG9ui6HYiKIa5HclmTyXRNTKuu9sB/Oz6Moev4CGMiW7XsO1yMAplKAorRCZUfUCDJXZ6/ZQut0U5rDrRZWNuChXNdpQIVUJRZyxWhGpUS4su/cLNxaC7m/5vOW16ziCMtRNE72lrR4JyWpyIbaDKFMBe2OP5zuoYSCt48P0OnZJ7/G1WoJEH08x/Z7byqbSCoVYbGNKzFZ+XCjBwsjW1OuTx+iUqyYuXdTprmvVpJczDSMU7ta7fcH+ycH77dP9vbevT89OD08O3x3+H733ft379snR2cnz1k3OcKdlVm47s/Hne9q5Y7Odo52To92OjuHh4eHp9uHh9v7+yfbp0edve3O7mnntHNycvZuu3Hu5NQKlo/Ar76G23v79atYonFQ2+P5q1ge2azoy+2//cOD9/v7+8ftvd2z952D4/bh2fb77c7+9tnxu92Tdyft0+39vbPO6cHhwd67s4Pdd+93Tg462yfHR9unx+8bp0hZnKmU+dJ0t9OiHhNJQlvvPyT20XwGIvcJlNWZB2M5O+Txfignlz/ZQjvoE+cKnRy30MfPP52zgcBSiTyGO7xrgsctdHryk4+rOT35KYwobkbe/+CdZakbNugDMmqKygoGDluZTtsVIxNsO0EZEZpNNXt2uxdboa2BoCYXS+QI39bHUiW7ZK/fOUz2+3t78UFn+2D78Ghne7sTH+338XbzhD1LLsZVDw9UI4ZMykxRZjisyNY1hcBqby/cjwhzRVRKCo1EjEPCAhFBNZnpXU+Tem1nu73d2Wzr/71ut9/C/0btdvu3RTUeTYs+FIz7SsSwKl9jQnSODtovSQhT5OYLBzmW9xJU68FQHEhvj8tzK+cVSdNSM31Tp2XEpQJppnipxbyFp6jZQyXSx8LYuLchQAsMU6R4hH41BX78caIfdgGNraKaTGnsIdErlFFbVibM5bGFZWrXCOLkTcmvKOaLrouR26t0dlROi+KEKJFtrtNiPDG/wzFxyuN8TJhNc3zhU0LmmYlP6Bk/xtLDo+y09XpRyaFivhmRNOWzjL4Z3pTtvf3e308+9Lo/H+8c7mqbsHjw7OT0sUf9RGvPsiEf9tpHEU4hrU/ROwIiZVm0vqBGU3UcG8BhE2HWu8eXG5EJjtHzSZM035/MVH9wrkZcUDUxkTEB20OkQT9XNpbKpG5ChGaRcqy119PLLpqmAkLrNm0/ibFI5EYLhi9Fo5P6aJU3fwvEyrOWyWiBkQF/mbLfrZMNQgNBs35yuaG/00BBsZqA0n4NagniNE5tsKCf6XCEjqXMBWYxcR3oTxY1zMp0ghIKS6eRqeGwfrIBFQ9kHQk+d18AvySU/stkh5pjZ/10UW44+elzt4U+ejvknMVwuMBxXGQitUJbpYZzSnv1JbkICqaEJVuWw0ZuWicHLzbqiPdBM5uWYL9Qcv8CyIaV4paMcDi1ROsfnylczln8wvTAaS9ndFmqXR1ZcIo0BJo6nxckz9SuegESQVHjHhc9CAld3uWs1x1MUWWB3Pxec7huoS4EnF7V7p0TnNIBF4zi51Dhpa1zsEWxChqdzGGOP2J5bre325vtg83OPmrvvO3svd05+l9gfj4X6Rc1w5/EetrufhTjztFm+xAw7rzdbb/d3ns+xiYrtXdLJj2cDvX+Go2XZnjb+YpC24QR4Rou2JTaW1K/4T91n3UIBnjHubhb1ua+NvfUd2GABUEkTfUDsf2pwBz5Nam/rvU/+wLXtbRiVKpsb7txMNIMgpGHjDPCnlHJpUSTMzucZ4OECHpXYQJ/9zkn0vt7ezsH4SKxhDzUhSUtTghJ/2zCOI8RAUpI0D999HjAAzLDMdzA9umMvIHt9u7hc1CSRFCc9hqXFn6BZDwztSsaDEdv4ZGoPf2nL27K92yuRGDhVUuzEWY5FANrlcs0Fxc391SNOBjQqVbStAXsb3FKw8cjLHAMpXzqFmJv7/27d0cnB6dn7963jw7bR6ed7ZOT42dJKkmHDKtcU3XJAvq8nK8bLocHKpRQvxIkiDaliaafLNf8QVZ9GfAcgpnQ3zm6wGyITsQkUxyltC+wmESoS4gP7RpSNcr7WqHbGvIUs+HWkG/1U97fGvJO1NndkiLeimGALU0s+E805H+92Nk52LzY2dupXSZzo7j5zCPEOndWw20hvd/CgVWHuBxhQZJomPI+Tr2+zEjjKiP1dFgFt8TLeyUcfqvolpgWk87haMqfPuKX6F7/VNgJLXTxUxcz9F5gFlMZ88Bv0dIWZwReii/KPSvtjigR5yWwXTV/xGNCo8QIL438CjofamixMKo/uBPBRuQsV7MMugppIKyaV8vaO42RW6KtOCP4ubAefREVaAxnrvVa5pIfZ9CBZFZ1HEnibHtvXzS2CIlUuJ/CQdSACn3OU4LZLETfmZ/RIMUldG15uuuLLmJkyBU197H3GApaxUTKQZ5qZb2kZkJfHqqftDH4DBEGOqL+nDNG0sZbm5EH1XNB+V91+X1mQJ/AV4APSSJ0ZWsCmlA1RMuBjdBj5fjy2Jbd0/qS07Hv7+8jihmG1AkstWY/JkzJLZXKTcBM7yaNz6YZe+YP0cNIjdO/4jRjmw7OTZrIjZpQSFMTNDDGUn4P+f+ynmM1tFudqDHDCiLz8dKYlcqphA9gVgsDFMkoUUKz5oNR7qa5vDGLmhiVbyMDwcK6SAZCFc1VyUCYBdmSluFLZyCEa7bQOn0bGQgW7u86A8Et5feUgRCu2/ebgbAKK/elMhCmVvA7zkCYcxXLI3/jGQgW56VmIHQb5RpU8gvK55WBv9ZUXmqugQXkP3hnaYGj9ckGBpAXTzbYOdrd3e3g/v7ewd4u2d5uH/Q7pNPf3Tvo7+zvdpIF6fUlwhmkwuOsEl9vg8VXMdkgoMWLRzk0IcZXTzawhFhuUHt37vD1qYNihtCpBBJ+caHzGlO92jHV4TK9xlQ3pNMqXF6+UEx1DX6reHn5jcdU11B5pS8xnxVTXYPsqt1hLjWm+gl6rOC15tJjqmtI9ANeh4ZU+GFiqqeR/v5jqkOMf6SY6hl4v8ZUNyTYjxdTPYMQ33JMdYjSa0z1isVUlxbnNaZ6dWKqSwvzA8dU19NhFdwSL++VeI2pfumY6jrqrrQ74lkx1XXYrpo/4ovFVD+F/Ao6HxaNqa5D9Qd3Inx3MdXVMJgv2o7KqK2lnsIubCPDQto4TfieCzqkmplNtOqMS8lou/FFjVvDJYcUX+pVS+mfJDHhthAi4iOK4RAMSTAP+kWp9EeR94ycYVZ0kajHtQ7PmTjWtsWsdnjU87qec/A55qY7kxZSSuCY+BaYx+ZhQex1LETU8IwIG33uGtdBnDmGKN+iXzhGgvyRQ1cwjjCDYB47rm3aBvIBowQr3Nfk/yMnYuLbYha7aDA4wodHh53+QRwne/gvcxLY4PIVKDxNRPhsKsoHzdZtB0PTN7sgoA1O7RNtziPFh0QTrtzf245se5k6Mo8wS1Jj3vpJKFNEbNogbJI4yssqlXf7g6Ptwc7ewUF/ZzfB+3gnJkfbR0mbtMnuwc7+NGkdvF+JwG76uTk5fMc2VB/R4UgTzrf4h8Z4Y4JlLqzVDuzt2dWytid/yODuYKoQtt0etPcPMG738VF7u39QImQunMCz7RU+f7qwXzzWXuHzpwvXOMF26UO2lp4xpbme2p7MWEBT2s+fLqS5fLdPFsJK06IvCDRXRwm/Z5ptOJLxiIxJyzZRbqEMq5EdgaMiLH/+fgnL7S59ano/u5atIi1E01q5DmTY+f6cIcnHBLIvtAzTlB7jiWkRYnNozq80FbY0cTXFTevqdNLyfh48jSqDFv3ntsylHtv06C8CKNA9uI2GXM+hf7qxdSwNNUMIDUIaMBuHIaEHvyICp+j86m7fj0lYnHLrCL751w2s3c2/b9D6+dn1e/TpfRFavH2ws71hYAofLPxRzq8F2QN94np/Ji4Y3YHrRzRg13bXn1GF0ydWuXyaZXEKNFjS4BYENYH3Wko7YGpUIbv9/bjAYxD7n7hw2ZTgxOwqFSzhdXV0KhGE1kiiENUSzKZotDS/Mq70cSEm0J9mBIdr+f2pwd20GRGUJ2icSwWD9PWJoOEjSflEKfKlzMN9gtYyNgxKUOrX1yL9XTDXJVc2c+HeFHG1eIH+pOEsTjsHqUTrzrRXWETDPzdagHlJGmnmQJyFgb2e4dbXhn+utQw8ZoS1jXo+ywIPYdDydThudrnwLN664kJZa8GKIQTXnmbT/PUmEEqKZ2tT63jz1xtzd6lKSrpDoqaF+CBPv6AKvZJt/84Hpj2aPuGgQTEda7lsmxRPeA79cQqpOwm4Sio+HXRJGbrJRRrpMW8ghxTC0EFyGylBJTiimQkuJIkxgEFDduIQlLvSsKYJ9MyEPpd+WMjFt7u7O1uSYBGP/uuPn+z35vNfFc8qK+/E0g+2+m8+szFPtHqYFJIZtplEkhBWWhG/CjUSjDLEiDIqIGdUcW3oGcHI+6DcJV4b6BMtgS3TAY8IgguFSmuNkJSLUj6ULX9eQ08qRRj6j5ax3qyyyQqgYJUEQMhxvuu2f80Pi6U+L+6x9IC2Siog46peQC7EeHrEGT9XeDLDUk5x2BfNv7TTFZ2/4ICOauBSo6XBpEZT8AQy3xJyrQZELp5xA26cUm+tu2ImbLw4Uyqw7e7W327t7u5UgAXLfZnqGkxoN4f5tU+M1mZ+sTnVdbj5cTX9pxi4cv7+F5y/RqcL3WHhLJE+gXBZIWdcvws7Pwj2MWFIAeyR1eaFuUuG+fq58k+1gskMskYr9CNCnhRmiIwzVcADoJsnb+zbtqe7j4GgkIfFFMWKoD5R94Swkgqm7rkxgmqUDJM5TwRJesu16a4Dq70AAsS9s1I1DbKMeBkg8775KVjaiuYbjGUeBjN6bcB5GPW3phdpLfxiWlobDdrSOiGKiDFlJNHaQUwlSW1iG4aEa+v6KaIxZD4Y0Ac/IjwDtQnebm2ZR8wTERfDjQhdi4ntpoCzTPAHOjaxTVRqe0/ScZZOkAKrvqpc6+VNcZ+kEt3TNAUVE86+e5KmgP31xaksBFXMo/x2rf4YqQuM9F5OcCIsiz+6MNtscQsH3rQBY6Jjbt7WqtoG/keOzyrGjuGWuSn8pHBuWIPDqCgT9EeOU6Mg2WfAPLOGYIEATlOHtbnFIQ8xyYyaMeLagtSv5Syx1ktFCkTgPsHO5RTYdNMQgOfX1jQxEg5+j41f2fvjlOt8DDPHmDFenImlHdYKKFB4RaYR6pPUJOZVN3y9dChLkJC2xoWEpYrGEzuC2SJGRmCpgjPdumzsKCW7GHCV9l7QyzDHrzLvb0cy73dKYqhV2s4FeOaEsMaNy9EpxlgzDip9uCiBaVo4CGZsaywbX70rnvUApa9wMJDBgMSQA6W1VMNEljLr5PridKNlvFe3jN8zTd5iTfy4RsC2nIcYRGUoDoINVONAmZ63cIYFXX9jPgYe+bbPDzg7Zh0dxUrMf4jAbxV+yiURSwyF+WynqzUgQpjsAM5pX3zzmNceuBSubKzv3mmuiDKjsGvhgvs8N0IXHjW2KbRSJnfYOxWslxisWs9Ftuuy5p8RviPgQSMQvsRF4IpjSlAirdoKk4BI4gIsYQav0cRJGXfBgBnCUFjFWsvm9AiE7NgvbIMWyiPMhkRGy5UWl8ESG+89F5OC5KCKjwmEjPLBLL0RM3RxenylSXtsmP3UDxWKiebtYCxNIElyiYxfzspsXvPPgq0P7C8cvrb8Jv2aPm9koYy0tPbiu5TV2snHaZ8Ihc4ok4pQtig5YRetzP4AaFZlgxjS0GV5l6rX0b7qIFDFNq+XE6nIeCtLsdJCfeF9ZLBb4uEXrrqZfFHQp0q2fFFetavijrGR6S4oTNP/0sE6gGgTI+EZwoyzyZj+GcBjlst//CzJIE/1Rr/RL0U0udG8bD5ohG+8kh1zNjB8gdPyYc6SGrsllyRZnO3rGD4u55R9CWZ3N1iyXIahEej13PwSwC//SOiOuLA2MRco5cMg2EDOKFWB4UxYlHqCp0srMeFr6JkQIz0zwkYtVbSQE1b/rEH1zb/WbmkfM9zDyZiytRZaEwQMaDbs6UEXqEi3KqfgF9USfRiEM6JW5vBfBeW4oMo3ph4XgL8qyC+iIBcEfVWRnyTO96YkT+P3TanJBfCvivKXUJQL+n6DqnIB/KuyvIiyXNDvh1eXV0VDCmMTvwfF58kF+HK6kcPiR1J5yjh/M5pMGezVUFAcTK96RyO9w5FtldQJ34/l29YSUENZ+gKKhI9i+9H1A4XFkKiVOUVWwb1kSbIqmlMzqL8X/eorO5YsNX8kFWsRynwzitgiyK2GutYM8lel7ks4kyxxV0n1awb5N64gfiU3kiXeD6kjhoGOPTwsMhmDcEcUfj9X0KMZyYU+Mqi/Ar0ExsTk1WDUF/w+qGjhpcL1iExs5pwc8XukT0KG7knflWaAPDs9FGXDIknHFnDJPbguQaZ5nGJC9DRf61iws9etOb0acVZl368EaEHq+sKIeIAFrQD7nWSuTonygPt6Je6ro8wH/idNU7y1F7XRulnT/z86ufps1xd97KLOdq9jQr4/4Fh/8d8b6DjLUvIr6f+Dqq399l7UiTp7JWDX//Hz9YeLlnnv7yS+5RuugNVWZztqow+8T1Oy1dk76+we2gXa2m/vBu1F/TLJaIDHNF1Wot/HLjLzoXUXQS5IMsKqhRLSp5i10EAQ0pdJC91TlvB7uVFLXPN0LT4/Xrb8R1O+iQ2twuyMKhaWrfDN2wQUvTTmQi3fGlb8wP+D76pSiMvolghGlmVKV3Azs3t0TFUqfP/YTtyNdqP2ZqezvQnlwmlch9V3YGSjl+EbV/Im4JrHGOW/66jpTLavxSVufitnYsIUly2U93Om8qdkCxb3NfczXEYa0KWZY9IkAt3YeW3VILDKsCJDLuif5gk+jTxlqijBo48ae5T3BccJlAAmItYGFshiSmRgq330j0uCBjxN+b0e2fbdLqpsQNbxuq+zt/EWpZTlDy00xjFQmtGHIqnN0rta8uhjF014/uaN0BoRhvw1SIeyaZu20ENKpWrZUjRBPpwpf+OHzHiWa1s1idBVSrAkKCUK5RKyw1B/ognF9AyYmbLhZqqzk25LUzUTPOOSIBrkYuMkgV7r9flNgGpTK4TLaLklISt7o4no7LSjTp3isFwUgvqcc6ikWgkqGT13qVcVrLnzy8Xx5byGjn7WmThYFPn21qSfoMP2dtT5Ayk8XJcbJkk3w/EtUb6onzR5dFgiyoZQxgs6ppk/YXwsJY+prbCrh2Cu8Af4WMAJoyngNzb2rQzsZOZgd53Z/U67NPVPIk2DOiwEiblI9HCUDVOLrcJDSOcF6ZJDaSNoB++IODKldzSgf2xStvkHIizGmcwNlLJlXUR1kKFSTRM1yWgc5BXbzDQob4Z98RZJmOQCrZNoGKHfCLltoV+pIHKExe0GVCShdySdIG8agwNR4AF0epiiBGWMiJmraoZA5iGLXLHAEq27nDs7qv2tjP/GDCQfR8/gZ8dtiuUj6BlpaceFimROflPmJZzGndXwimZ00/WSOHIoPByCvLBDfuy79rcBczvujUIut6dIDf+5x+2QnrdDFyDUI/O7wtbadI7DhMpYEHBUTu8wOyZAEIw3a10GVJB7nKayhQQwv2wZzxROUB+nmMVEyAX8DUtzrgOi56fGuNKsUvTH8KtSL+ubnmVLdEl8zGzlbcAO3IVN8eO5kjSZq5OLPznylBGB+zSoM++OkJqfHjtL9FFSGm6OjGFcCwCqJBDbIpYlN2KDhF2jTi612A80IOUDp5Lo00LEI6qI6ewKCKoKxTAEAgaXqdegptryXU7n3/TSY30Q3qGdgs9Az9X93D3b0H+Y9lEpPPiXKYZpoVNXxZgL9N5KhY1SjQCTiy/fbm39keN0Ioc5Fklk/oYeJH/ck/6IpNnWgPeggl26pbXRlCRDoofeKiHYc5o9kdFIjf/1TxjIA1YmRvHsvzdqK4y5qo8uy7teiX3zrzWH2wLxBnGqjyVX5mNJHAQtsUoT+1LnJQrJGAq+WSYrLVzZoxYWTYP2ahEXw634Tsqt+lL3v3Qb9wcJMPjG3QyVtQi+qF8I2M72jJVe5cApnN7T89aNMGPTxXckGlMlCKwXyMytAf4DNk/61/iO9KBUQi8AUPZiQbSR+K8TaIVTmjqU6ZQYHeLsIeNSy6STX85CTP9dyxnnTFuFH7vI9ARE21FnO9pvhQXByqSxFu6nq5Moah5YDl2qlr31nOwO7jRBmzNX+FQ+snT1265uGWfsu7OmJFqa1qUp4yhihdL6+emGKztj25WVSjnVH+6AsWbbCJ2HRTlQXr5KtpPYgV38RJX25YGbbaH7EVY9Knt6K9Fkw+6Z6X1SmqGyZ85P/z1jLTdNf8p2u924zyDU7ibL645yjAQxhUZnC7OSbWElmymuPqaKDo1pWKKVWzS/k5Kp9asjXP3KxUO62adMfwue/XhI/0v/8ZOn836nswCZNcP2lrqJrAXOBZIxZvXsPrPbaafdOYwWYSg9FyMiuiMs4cvqO3Nty5jNUl8AJGRAqkX5mjDcT5s3p4y5IFG/3KrwKUQHKcdqplLf1UOaOkUCs6G9/29HbW2bdNpR21Yq03+iPnG3UmMuFZLkjoiwgu87rXRLOyLX1r7WYaUkUo4h4ABOlCzlVDlijYkSNJZoHSuF41t0B8FxhQfaFM99oGrSQpmgdzQlQ2K7J9hIJkWEaSax0UJ0nOFYFaOGcUl6DD+ufm0oYFg9lI1iBJg2bGeFmGdkhgJTo3A64wXYfTPhca5R3qjV3feivcWWnrA7KjjTIze6o18iD5yFID7FDJhNkC8ZDdxjV66FFlk5iFahgujx5YotnSLjjItVXbVrC91TCwZX0GOscrMAmtQJDUpFFssEgX92DeOX3UcNqL7c+w5wkVy6XnMlT1PhlFi//OV0o1BEoN6mwooGl/awPMDPmN1SNoSrhbULfr/WQmsfSELz8Zrh/rWf6XC0BkujjVt0t60X24thPyJwiJx2HEOsbjGXgqmKsXaitq3NOAHfb0IGlAUkszZQ8XBp7QLugieoRPyekcRoVpjhofH/vT//1L2OPoqhaTuI1uELLYTR5+6mxiVBjLPNTPBB0D4wbOzXQvcjroUHla6Dh+JoRNIMzg+4CZEkBqbVmjnIFa0ZZpwFrKMIHkuEY8GlUf7vuUiTGazL7pKIUamiIb8Db9CmFV3AxvXCw11wNWFjuzxL1Gw8R9RqN1DRUFMWhIs7aDF0+lVElGPHkD6zuaDKLhQSZIgFxLYEomMxCtcaJ3qquATCk77ih732UdlFDL0ET4peq3N4id+YluUaCjh8zF2bsbr0RnROY725YPiglassdXwPvcnU9CRLJyjlw6Htg4WuL7pIC2VzY5fQIYWT1vVpLhov/8VRh8S50vom6lOGBdX6U3frw/mHs/JszOa+9HkCz8ABjdOJhGYJ0E7GQcnh5ubW7/FfXc+ZsEWtCUGXpieXfrsF3T98PADE1N7oH6CH5E0Ew9gRR1iOiHQ8eHr2aZMwffok5WbhghQZKLZpkn7zBlrZQQuf0jVanxThBv5+19xPGkD0y5Ec4e29/ZsNj97ZnV1UrIqQ9wCM6hWAuyMsLlBlqwyKI4XpXGnoEVZ0tlcEerWtYxDdqFRGQdfNG9v8yo4IP8cpJUxZgja/7cIpbGJ9HEH+0rIirn0bU9vWOIDDVoxe7x5fbkQmxlXPJ9EdFhN9gsSVrWr++U7yRhkJ1gtcYX1oA6+3KMQ+m1Ut2oDpHXB62UXTVEBoXQ93T9MkxiKR1lwopY2R+qbxb/4W9PZorNFA7ItYjSbkvge5BkqL8/oO/nVEsE2GoTU70uoLOpYyF5jFBHXNHfFJ427tnjar0Jhc1qHdvDO5xWkVm5E3X3XTi9z3GteqXgt9/PwT1G4vynFD9/FHOKS0D5/LLSvdiPyDZiotkX6h5H5BBFet9/jiwuKcxS9AgxVsQd6cJFM7ZkGy/IDtyhlXPWj41wDVpKxTlG0lOiYI+i3SeFRRfk2DoZSzIYEwOkkT6HFxh1OazPCDb7c32webnX3U3nnb2Xu7c/S/2u237ebhPVz1zD3msjAFH868WHaONtuHgGXn7W777fbeYliaNgq9WzLp4XSo98toWWHrx24+Hw5nAlJUqQfELanfwJ+6jQ+sANc4F3fL2qwQsKHnM3jaYC2SpvqB2P5UYIv8OpQsWjurLH72jqJa+mibP9vbbnwVFBCJPGScNWstOtW1rUSHMztc0bOLCGhuUl5sE8QzP6L7e3s7B+HCsIQ81MVtNENe0j+bMMhjiIM7iP7pL7qCtZYZjrXhi/pU1Vs72+3dw+buLkFx2jO3hUvicpvqbaZ29/JwTHqWrz+dwW0FQk8qwuLgjgIAGNioCmgkA1yRjTBEftC4hagKsjKM90BZDw8HwzTVihNcc2WZSdYoDV/0g64l/t7e+3fvjk4OTs/evW8fHbaPTjvbJyfHjSWPdystXciel4tMhEvggQolzq8EgpLHYwJXg+Vei8iqF841hv7O0QVmQ3QiJpniKKV9gcUkQl1C/E39kKpR3od4wCFPMRtuDflWP+X9rSHvRJ3dLSnirRgG2HrYax/Bf6Ih/+vFzs7B5sXOXn3XRm3W7O1vLnAMWOfIargApPcBOLDqkJUjLEgSDVPex6nXWxlpXAWgwH0VTPyXsfAdTqto4k+LPeeY05vyURu/e/1ToaO30MVPXczQe229UxnzwAdg7nvA4n9xLllp075EkEUxXDXb/jEhUFrwl0B4BQ35GvwbofcDGuT2cn652l6Qk2huXkD1qmXbnacQ2tSQvEV9AmEamMUjLszHzdhFKds7xXfmmRIo/xuMf+J6ZNqzVb/u78fc1Rbc3KepbZ0O1x8a5PAWx9/gQILliEsVHCSGbjilvjV6htXIPRw8WAOg/ndKMkFiuDXbhJur4kW4JoRPtJxfiZlL9izBp/GLFB2TP4tqKbPAM5kxUw+P6dDETr9FSuSkPLqhSGlYDhvMfmU+9Or4aAbqfn0g3AxCWoa5gEUxk9XhNwfp9QqFzz2KFgy66Jo+OrImrjZ9iIwokypwsj9JI3ALmXeRexfRxG2LOOV5UuyAE/3Rxb0INCYKJ1jh+k3xwf5qgpri0qsQvFvYZjhJevBAzw2pn4yJlCb4MtwjJczhpYiO8TCoTl/UqhrTTdyPk872zu7jDHKuR0Dnpz4s2IDrKGLZ46/oWK8UPMTTJGRUB5CGPzJQOVyfWOrahx9d7mAOB2ARJvz4NB4h/3zjmebg3qm55mXjYLYxjkeUkV5Q9eHxyewLYZmIeecKow97cwi0x9+ad9ZMcJBicy6cfbz5ugkyLLTLx+coPVo7vhMLCY9vgVetXDh1n2u2l/kNdBN9PqYpiZXr/W9+0ztcjrhQPSOZC13DHcdmvk0vE2Ycmx4s1CwJ05wOUB2xoqeExAoIVv9KLdFmTKUlTvPZQNJNWZcNZp16c75JF5/OtsRHf0XXH08/vkU/83utXoxxZqqc/FcFltJBjx4/7NFseY68TDcgRI5z9flb8O3P5lPNIOdswENutccCNG53siZgUP19LXvac+PspBtWPHDdxWVEYhlNxmlknzNJtVgYvzTjbLN4s9w22SLyOKfPXppSzVA3RJ/zlGA2J3kHBUUgua5Y9uq8XEb9nKbzmAH+9F7rHJ522kdr84HzsYtghjCOqx6QmCekdh88BotUgqh4ND8wbhZTYJlNPAfe5n0iGFEQYmL58B/hdzXjFr97nausQBWDopALH5eqxUtPStYS0I/z3DTFM57Ui51GmzmgQMaNm6u6uHqqvEaGLzrTFU/Q5/PT+oloVpmn9NX8U5xfVWcAwz3D8cuRrRixOhlPKofKMydzZe5mTDZlBj1/QjdgXWUKPeP/+3//P9LWr6uCZM+Ivz37NAp+7o1xllE2tM+u/W1O0RHgZE/PMc6qIEM5ZuO9Wzm4A9jqgZckhRSx1QPdQ1YPuCBZSmMsq3Wgn8e9xbgzNk1CspRPxlNOgedPXIw7Y2JwKQ7y9MVRDgaeMfUTWuuiE/th7V1JQgeQz6yQGmETAA8/+LrHImeKjsnGkrT5pliYqa1yYc/xQrO48l/UjGt/LHQK79Co0wGKsVEjBYA8zEsZO0NUZDs8YnZYjP/DU35L8SbOFU+ohKS3Av3/3fyKTu0vExQ+hwKvy5MOrJqhQg3MwuGHnOXatc9FxsNXzm1r4NF0LnAb6sAHHoCgOF/9nFMeh7mmO8PxyBb9HuFSQQQbUBZjhvoEEapGBV0TlOSmCozCQuWZu5M0A1HoZjA29Ri8TxbyLzIs8JgojZiweY+wbkSBORZp48N8oT+2bCI/gAaZTzjVQyhpol/Or8wTlr0QTVqQmgKJkCWQIAVKSaBMPQlt5kYmeJLHqjkhIRzL7107jDYRPG6PTbswu5SmfSN9Hcr1YOaNJ6YOkvMbzmze9TfSHv2AF6QWs1AhlLJ6OHKRLjb7508XaMTvTSSPmc5yK0DyGNHjXJDybimbyDNm/XVEYBsU+N1j6VncuhNwrkaEKV9FSSDGlbcSp++e1mz5jxHBQsH10pgzqrhYm5JdM8SOfXqm8J55cQKz2rfLlyWzJf5Urd4FzutryHI2k5rNWGshvdgkpdWZ9ne9aGEnyMb7k4i3SEKqYRWx5xqwJbSg0dN/eN8WJXQxoJ6Noq+IaJJX6idVGbOC7DVXOHUIQkY8kapurMcQyWUtGlNxlJW5T90BRRka01hwSWLOElmjN8cjMrerNRdpVHlhWt+ZAVJ57Y9N7poe0YJQTsy9UXF204IsQ/3/Rkrpj/rYg7/lTc1GCzyN8yBSafG1ECI/O3ueD3xXEqMI2JXXWsCJEeOQMs6G4Glzz05FLvuXNPOfX9Vg+Qx3zvnVo1Ceh1CVIXFei3LUKWTA0sxVHY/d5bXJKZU8vSMJoplLVCzuLHMBdgzcStebciW+t5U2ksq6LOJsN4VqudCL4CR3DLGxkEfg4uodJRSH8ohF47mqcTUi8W1vWhQsANoxUvyWMKeyQiazpFrYYUZ4LtMJouyO35LEdUAbmMmlqRpd1Fy+h0pyrgoxOr8y3nx42J3qrpjz6WXXlhKrogb39RmuCj5Nph7UeZhT1NMxsZVDQLvJTFa+dX+B1g26synoaS5kzd8AM6gl8JRWoglLgofha6eyMfKgQJ4keUoS83L0F6eryHw8xhDO6ZSVD5YB7C9z6ijFOOhpHWXtShBpzQioU4+lsqE1ZEwhDtsaH9jCC0ZDwZtmhf1iEpZknDIlW7DqMlh1qkboZswTEHvpTbT2hPpTw7BQ8KYUH/XEAV7YdR4wk7ou8zgmJIyoKm4/76sc9XITDzBNSeIX3QqiYNG1yEYp57d5NueCF2PMseAFqMFEpaux2SuyskfYS59DxZGQs+LWckjvCJt1LAhVJc2jCphXgtz5YWqJw1IiDOn34DBxh1v0tXQyJ54mTI2IonHgFlvr+i9NJN68Iiocq55eMxYomNDU1Ejm5N25jCnvo8PxLR6SXrVm0uPvQdrS84THuR7CdOgynAfFXkFBB42di8TIFR8DOZVcxswZps9iV32oit4k5bhqH1UuDUxtvplRq/2U9yuDQGGVySxkza+mJMk0GOGwvTFtbpfqd3xtVz0KsmF15fGlIlXpML1XH9tiU5Ytmm2/zWIM9AhzPKJqzqZE4XTJBSOTZaOXNAKSCFEqUPmCIFY5JAznkrJ8vzAHalLh+PbpVzzvmmaRz0KOPGREUDJd42HWULOGe4Jej9MMzRadTxDO/HtEwhWPMA41kUYEvRljcfvGyLOZcIAuPROQmgNuTkD4YCCJUdLBEIBONXdg4tjtZNV4OBrTlLqjsQ5I6Kyo6Hg66e57W73YJWza7lx6AREXaEww1E2eCs+vh22lVzQElLAqgVcEzCL6YsJz1ZMjOqh3Li6d8+RUO+fy23UHHypJQSpVdUVmB9m5f3MQfpDioW1BYjsDSZOkTAQBax6ziSUoAoLWaVruX2YtaNvxPcNDUhj1I6Wy0Li7vr5qeOVgR0CNTDs9TTP9uLgXQnOYdlMtShcy7LrWmMtF6h3qljRVlbVSoXKRg7XPk8mLbY2pxvblAWdtjbm482csR85lBBcPDnlAwPtrfcEN8La5Z6TtPpiYS7HUVg+MagkiSEIFiSuM/RgSTyDgkuj80LYFo4EVC6gWAWldvnsGUxG6wFIhCo10ioaJzn/0+dMFmEJwR16ZURPFDaTfkCN+z+rxHRGckKl4KTTb/EGzTaC5aAHXxZhxZhbCTO5WtvBg291q1q+G9Zt6Fqb8J3r0FE+ge3vOEqQEzYzvdF6XgnM9z713SuD8nxW6eF9Dn6h7QpgtmtOfKFAlLD2g27p19dwLqhRhCNecw8XugEdteIKRJxZyLqJgUqijyxnCqSC4IhFQkGpYLV0ZeH7cv0uu9HE2KCZzvT/18Bok4FAuTOc6rA+MAX1ogZ1eKwCQcx8mnJiRtBiAtnn2rIH2++APAM2BlV2ZU8vEARDTP1ULkIaCrmKBokaqz9OXfaiG1XqNZPW8/MbDRSr73bCpxly6Zak5dMw/Q8ZXTkBfkBP0lic9KwYW4oRH+UDaexpbnThLiSIlyVMjMaqSwkiQJyTGChPZcXjPHE4vQ2ZzneZ2l5PxIcH9rVj4pSZ+jXA3x4Dem8EpAZ7x0rlppb9ej2Llqht3SvZ/uyvnNKcF3f3lNQLBoAQldyTxwWX2VhBAQRaWqB4YEEAvLq1D8FzQoWMUpARm0jQ7iVBX85PRfCvDmStbqihO0fXJVamPr1JknKkInbHE6s1QFbGQ35XREmrvbUsHxCqfBavCxdYgVnFoD+sFAd10TmPYvI2a2MJ6Cre3rRrcyDDOuGhy6Tn1+LMsY+gi5dpFvbRd4Em/sFlgd9Ji+75qLdXueyIV7qdUjhCe3r0N9PjiSndVdsMXsLMeoWih9+pPUpGsoB742bQ8KpN3VQjlbp95fCv3wpvnjyf/6O7pc+Fh7sAYN0Y9UWfdOAcTTYmOt0+Ijufu0Ivuau3QitIQ7s5gZ95R7MimH7IBMI8oY36jBoMoXiL9qvCjP8fSMA5CLxVhUAARGkA1OdLSxkEQAWM0OsqCInY9xlUPZEK1PnIRRFfiU1f26C06iA6n2veElCvqI1GGBvjOpCxMN+yIitLMNxE6wyKlWs9X1frKniXeyFKvGAganKqu/Dim0yWvH8NpBhEWRBRmvonQBVYviOVXly8jzBI5wrcvdmJVJMyAMi1eNKh+sjmsuMrAq3ewTc9jWKbZep4SBeGElUZKYU2pxxD1mses+nPoiduAR6vNVeB9uuIcmlV1Ds2qPOcEMo3HoWVxfvLhak4JbN+sp/msSldXJkp4PsFrvRiysrqNQsMubT3mAdLIobN4xD/ZgcGR8hI2gh8ZfQo8L59Ipg3NspSYk7VeOh7x/wsAAP//A26uOQ==" } diff --git a/x-pack/heartbeat/include/fields.go b/x-pack/heartbeat/include/fields.go index a7f85b08864..6ed4d0ea2aa 100644 --- a/x-pack/heartbeat/include/fields.go +++ b/x-pack/heartbeat/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 "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" + return "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" }