From 660838202401b0f61c3062f491c95261c5ae5501 Mon Sep 17 00:00:00 2001 From: Kari Halsted Date: Tue, 12 Dec 2023 14:07:51 -0600 Subject: [PATCH 01/17] first 2 pages --- config/_default/menus/menus.en.yaml | 2 +- .../collector_exporter/_index.md | 529 ++++++++++++++++++ .../collector_exporter/hostname_tagging.md | 429 ++++++++++++++ 3 files changed, 959 insertions(+), 1 deletion(-) create mode 100644 content/en/opentelemetry/collector_exporter/_index.md create mode 100644 content/en/opentelemetry/collector_exporter/hostname_tagging.md diff --git a/config/_default/menus/menus.en.yaml b/config/_default/menus/menus.en.yaml index 89b20c62d9b06..20c2a9637934f 100644 --- a/config/_default/menus/menus.en.yaml +++ b/config/_default/menus/menus.en.yaml @@ -684,7 +684,7 @@ main: parent: essentials_heading weight: 46000 - name: OpenTelemetry Collector Datadog Exporter - url: opentelemetry/otel_collector_datadog_exporter/ + url: opentelemetry/collector_exporter/ identifier: otel_dd_exporter parent: opentelemetry_top_level weight: 1 diff --git a/content/en/opentelemetry/collector_exporter/_index.md b/content/en/opentelemetry/collector_exporter/_index.md new file mode 100644 index 0000000000000..9a75b2526e3e5 --- /dev/null +++ b/content/en/opentelemetry/collector_exporter/_index.md @@ -0,0 +1,529 @@ +--- +title: OpenTelemetry Collector Datadog Exporter +kind: documentation +aliases: +- /tracing/setup_overview/open_standards/otel_collector_datadog_exporter/ +- /tracing/trace_collection/open_standards/otel_collector_datadog_exporter/ +- /opentelemetry/otel_collector_datadog_exporter/ +description: 'Send OpenTelemetry data to the OpenTelemetry collector and Datadog exporter' +further_reading: +- link: "https://opentelemetry.io/docs/collector/" + tag: "OpenTelemetry" + text: "Collector documentation" +- link: "https://www.datadoghq.com/blog/ingest-opentelemetry-traces-metrics-with-datadog-exporter/" + tag: "Blog" + text: "Send metrics, traces, and logs from OpenTelemetry Collector to Datadog using Datadog Exporter" +- link: "https://www.datadoghq.com/blog/hivemq-opentelemetry-monitor-iot-applications/" + tag: "Blog" + text: "Use HiveMQ and OpenTelemetry to monitor IoT applications in Datadog" +- link: "/metrics/open_telemetry/otlp_metric_types" + tag: "Documentation" + text: "OTLP Metrics Types" +--- + +## Overview + +The OpenTelemetry Collector is a vendor-agnostic agent process for collecting and exporting telemetry data emitted by many processes. The [Datadog Exporter][1] for the OpenTelemetry Collector allows you to forward trace, metric, and logs data from OpenTelemetry SDKs on to Datadog (without the Datadog Agent). It works with all supported languages, and you can [connect those OpenTelemetry trace data with application logs][2]. + +{{< img src="metrics/otel/datadog_exporter.png" alt="Application Instrumented Library, Cloud Integrations, and Other Monitoring Solutions (for example Prometheus) -> Datadog Exporter inside OpenTelemetry Collector -> Datadog" style="width:100%;">}} + + +## Setting up the OpenTelemetry Collector with the Datadog Exporter + +To run the OpenTelemetry Collector along with the Datadog Exporter, download the latest release of the [OpenTelemetry Collector Contrib distribution][3]. + +### Out-of-the-box Datadog Exporter configuration + +In the `exporter/datadogexporter` folder is a working example of an out-of-the-box configuration for Datadog Exporter. See the full configuration example file, [`ootb-ec2.yaml`][4]. Configure each of the following components to suit your needs: + +{{< whatsnext desc="Exporter components" >}} + {{< nextlink href="/opentelemetry/collector_exporter/hostname_tagging/" >}}Hostname and tags{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/otlp_receiver/" >}}OTLP Receiver{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/host_metrics/" >}}Host Metrics{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/docker_metrics/" >}}Docker Metrics{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/log_collection/" >}}Log Collection{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/collector_health_metrics/" >}}Collector Health Metrics{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/trace_metrics/" >}}Trace Metrics{{< /nextlink >}} + {{< nextlink href="/opentelemetry/collector_exporter/collector_batch_memory/" >}}Collector Batch and Memory Settings{{< /nextlink >}} +{{< /whatsnext >}} + + +## Running the collector + +{{< tabs >}} +{{% tab "On a host" %}} + +Run the collector, specifying the configuration file using the `--config` parameter: + +``` +otelcontribcol_linux_amd64 --config collector.yaml +``` + +{{% /tab %}} + +{{% tab "Docker (localhost)" %}} +To run the OpenTelemetry Collector as a Docker image and receive traces from the same host: + +1. Choose a published Docker image such as [`otel/opentelemetry-collector-contrib`][1]. + +2. Determine which ports to open on your container so that OpenTelemetry traces are sent to the OpenTelemetry Collector. By default, traces are sent over gRPC on port 4317. If you don't use gRPC, use port 4318. + +3. Run the container and expose the necessary port, using the previously defined `collector.yaml` file. For example, considering you are using port 4317: + + ``` + $ docker run \ + -p 4317:4317 \ + --hostname $(hostname) \ + -v $(pwd)/otel_collector_config.yaml:/etc/otelcol-contrib/config.yaml \ + otel/opentelemetry-collector-contrib + ``` + + +[1]: https://hub.docker.com/r/otel/opentelemetry-collector-contrib/tags +{{% /tab %}} +{{% tab "Docker (other containers)" %}} + +To run the OpenTelemetry Collector as a Docker image and receive traces from other containers: + +1. Create a Docker network: + + ``` + docker network create + ``` + +2. Run the OpenTelemetry Collector and application containers as part of the same network. + + ``` + # Run the OpenTelemetry Collector + docker run -d --name opentelemetry-collector \ + --network \ + --hostname $(hostname) \ + -v $(pwd)/otel_collector_config.yaml:/etc/otelcol-contrib/config.yaml \ + otel/opentelemetry-collector-contrib + ``` + + When running the application container, ensure that the environment variable `OTEL_EXPORTER_OTLP_ENDPOINT` is configured to use the appropriate hostname for the OpenTelemetry Collector. In the example below, this is `opentelemetry-collector`. + + ``` + # Run the application container + docker run -d --name app \ + --network \ + --hostname $(hostname) \ + -e OTEL_EXPORTER_OTLP_ENDPOINT=http://opentelemetry-collector:4317 \ + company/app:latest + ``` + +{{% /tab %}} +{{% tab "Kubernetes (DaemonSet)" %}} + +Using a DaemonSet is the most common and recommended way to configure OpenTelemetry collection in a Kubernetes environment. To deploy the OpenTelemetry Collector and Datadog Exporter in a Kubernetes infrastructure: + +1. Use this [full example of configuring the OpenTelemetry Collector using the Datadog Exporter as a DaemonSet][1], including the application configuration example. + + Note especially some [essential configuration options from the example][2], which ensure the essential ports of the DaemonSet are exposed and accessible to your application: + + ```yaml + # ... + ports: + - containerPort: 4318 # default port for OpenTelemetry HTTP receiver. + hostPort: 4318 + - containerPort: 4317 # default port for OpenTelemetry gRPC receiver. + hostPort: 4317 + - containerPort: 8888 # Default endpoint for querying Collector observability metrics. + # ... + ``` + + If you do not need both the standard HTTP and gRPC ports for your application, it is fine to remove them. + +2. Collect valuable Kubernetes attributes, which are used for Datadog container tagging, report the Pod IP as a resource attribute, [as shown in the example][3]: + + ```yaml + # ... + env: + - name: POD_IP + valueFrom: + fieldRef: + fieldPath: status.podIP + # The k8s.pod.ip is used to associate pods for k8sattributes + - name: OTEL_RESOURCE_ATTRIBUTES + value: "k8s.pod.ip=$(POD_IP)" + # ... + ``` + + This ensures that [Kubernetes Attributes Processor][4] which is used in [the config map][5] is able to extract the necessary metadata to attach to traces. There are additional [roles][6] that need to be set to allow access to this metadata. [The example][1] is complete, ready to use, and has the correct roles set up. + +3. Provide your [application container][7]. To configure your application container, ensure that the correct OTLP endpoint hostname is used. The OpenTelemetry Collector runs as a DaemonSet, so the current host needs to be targeted. Set your application container's `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable correctly, as in the [example chart][8]: + + ```yaml + # ... + env: + - name: HOST_IP + valueFrom: + fieldRef: + fieldPath: status.hostIP + # The application SDK must use this environment variable in order to successfully + # connect to the DaemonSet's collector. + - name: OTEL_EXPORTER_OTLP_ENDPOINT + value: "http://$(HOST_IP):4318" + # ... + ``` + + +[1]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722/exporter/datadogexporter/examples/k8s-chart +[2]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722/exporter/datadogexporter/examples/k8s-chart/daemonset.yaml#L41-L46 +[3]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722/exporter/datadogexporter/examples/k8s-chart/daemonset.yaml#L33-L40 +[4]: https://pkg.go.dev/github.com/open-telemetry/opentelemetry-collector-contrib/processor/k8sattributesprocessor#section-readme +[5]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L26-L27 +[6]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/roles.yaml +[7]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/deployment.yaml#L21-L22 +[8]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/deployment.yaml#L24-L32 +{{% /tab %}} +{{% tab "Kubernetes (Gateway)" %}} + +To deploy the OpenTelemetry Collector and Datadog Exporter in a Kubernetes Gateway deployment: + +1. Use this [full example of configuring the OpenTelemetry Collector using the Datadog Exporter as a DaemonSet][1], including the application configuration example. + + Note especially some [essential configuration options from the example][2], which ensure the essential ports of the DaemonSet are exposed and accessible to your application: + + ```yaml + # ... + ports: + - containerPort: 4318 # default port for OpenTelemetry HTTP receiver. + hostPort: 4318 + - containerPort: 4317 # default port for OpenTelemetry gRPC receiver. + hostPort: 4317 + - containerPort: 8888 # Default endpoint for querying Collector observability metrics. + # ... + ``` + + If you do not need both the standard HTTP and gRPC ports for your application, it is fine to remove them. + +2. Collect valuable Kubernetes attributes, which are used for Datadog container tagging, report the Pod IP as a resource attribute, [as shown in the example][3]: + + ```yaml + # ... + env: + - name: POD_IP + valueFrom: + fieldRef: + fieldPath: status.podIP + # The k8s.pod.ip is used to associate pods for k8sattributes + - name: OTEL_RESOURCE_ATTRIBUTES + value: "k8s.pod.ip=$(POD_IP)" + # ... + ``` + + This ensures that [Kubernetes Attributes Processor][4] which is used in [the config map][5] is able to extract the necessary metadata to attach to traces. There are additional [roles][6] that need to be set to allow access to this metadata. [The example][1] is complete, ready to use, and has the correct roles set up. + +3. Provide your [application container][7]. To configure your application container, ensure that the correct OTLP endpoint hostname is used. The OpenTelemetry Collector runs as a DaemonSet, so the current host needs to be targeted. Set your application container's `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable correctly, as in the [example chart][8]: + + ```yaml + # ... + env: + - name: HOST_IP + valueFrom: + fieldRef: + fieldPath: status.hostIP + # The application SDK must use this environment variable in order to successfully + # connect to the DaemonSet's collector. + - name: OTEL_EXPORTER_OTLP_ENDPOINT + value: "http://$(HOST_IP):4318" + # ... + ``` + +4. Change the DaemonSet to include an [OTLP exporter][9] instead of the Datadog Exporter [currently in place][10]: + + ```yaml + # ... + exporters: + otlp: + endpoint: ":4317" + # ... + ``` + +5. Make sure that the service pipelines use this exporter, instead of the Datadog one that [is in place in the example][11]: + + ```yaml + # ... + service: + pipelines: + metrics: + receivers: [hostmetrics, otlp] + processors: [resourcedetection, k8sattributes, batch] + exporters: [otlp] + traces: + receivers: [otlp] + processors: [resourcedetection, k8sattributes, batch] + exporters: [otlp] + # ... + ``` + + This ensures that each agent forwards its data via the OTLP protocol to the Collector Gateway. + +6. Replace `GATEWAY_HOSTNAME` with the address of your OpenTelemetry Collector Gateway. + +7. To ensure that Kubernetes metadata continues to be applied to traces, tell the [`k8sattributes` processor][12] to forward the Pod IP to the Gateway Collector so that it can obtain the metadata: + + ```yaml + # ... + k8sattributes: + passthrough: true + # ... + ``` + + For more information about the `passthrough` option, read [its documentation][13]. + +8. Make sure that the Gateway Collector's configuration uses the same Datadog Exporter settings that have been replaced by the OTLP exporter in the agents. For example (where `` is your site, {{< region-param key="dd_site" code="true" >}}): + + ```yaml + # ... + exporters: + datadog: + api: + site: + key: ${env:DD_API_KEY} + # ... + ``` + + +[1]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722/exporter/datadogexporter/examples/k8s-chart +[2]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722/exporter/datadogexporter/examples/k8s-chart/daemonset.yaml#L41-L46 +[3]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722/exporter/datadogexporter/examples/k8s-chart/daemonset.yaml#L33-L40 +[4]: https://pkg.go.dev/github.com/open-telemetry/opentelemetry-collector-contrib/processor/k8sattributesprocessor#section-readme +[5]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L26-L27 +[6]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/roles.yaml +[7]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/deployment.yaml#L21-L22 +[8]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/deployment.yaml#L24-L32 +[9]: https://github.com/open-telemetry/opentelemetry-collector/blob/main/exporter/otlpexporter/README.md#otlp-grpc-exporter +[10]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L15-L18 +[11]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L30-L39 +[12]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L27 +[13]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/e79d917/processor/k8sattributesprocessor/doc.go#L196-L220 +{{% /tab %}} +{{% tab "Kubernetes (Operator)" %}} + +To use the OpenTelemetry Operator: + +1. Follow the [official documentation for deploying the OpenTelemetry Operator][1]. As described there, deploy the certificate manager in addition to the Operator. + +2. Configure the Operator using one of the OpenTelemetry Collector standard Kubernetes configurations: + * [Daemonset deployment][2] - Use the DaemonSet deployment if you want to ensure you receive host metrics. + * [Gateway deployment][3] + + For example: + + ```yaml + apiVersion: opentelemetry.io/v1alpha1 + kind: OpenTelemetryCollector + metadata: + name: opentelemetry-example + spec: + mode: daemonset + hostNetwork: true + image: otel/opentelemetry-collector-contrib + env: + - name: DD_API_KEY + valueFrom: + secretKeyRef: + key: datadog_api_key + name: opentelemetry-example-otelcol-dd-secret + config: + receivers: + otlp: + protocols: + grpc: + http: + hostmetrics: + collection_interval: 10s + scrapers: + paging: + metrics: + system.paging.utilization: + enabled: true + cpu: + metrics: + system.cpu.utilization: + enabled: true + disk: + filesystem: + metrics: + system.filesystem.utilization: + enabled: true + load: + memory: + network: + processors: + k8sattributes: + batch: + send_batch_max_size: 100 + send_batch_size: 10 + timeout: 10s + exporters: + datadog: + api: + key: ${env:DD_API_KEY} + service: + pipelines: + metrics: + receivers: [hostmetrics, otlp] + processors: [k8sattributes, batch] + exporters: [datadog] + traces: + receivers: [otlp] + processors: [k8sattributes, batch] + exporters: [datadog] + ``` + + + + +[1]: https://github.com/open-telemetry/opentelemetry-operator#readme +[2]: /opentelemetry/otel_collector_datadog_exporter/?tab=kubernetesdaemonset#4-run-the-collector +[3]: /opentelemetry/otel_collector_datadog_exporter/?tab=kubernetesgateway#4-run-the-collector +{{% /tab %}} +{{% tab "Alongside the Agent" %}} + +To use the OpenTelemetry Collector alongside the Datadog Agent: + +1. Set up an additional DaemonSet to ensure that the Datadog Agent runs on each host alongside the previously set up [OpenTelemetry Collector DaemonSet][1]. For information, read [the docs about deploying the Datadog Agent in Kubernetes][2]. + +2. Enable [OTLP ingestion in the Datadog Agent][3]. + +3. Now that the Datadog Agent is ready to receive OTLP traces, logs, and metrics, change your [OpenTelemetry Collector DaemonSet][1] to use the [OTLP exporter][4] instead of the Datadog Exporter by adding the following configuration to [your config map][5]: + + ```yaml + # ... + exporters: + otlp: + endpoint: "${HOST_IP}:4317" + tls: + insecure: true + # ... + ``` + +4. Make sure that the `HOST_IP` environment variable is provided [in the DaemonSet][6]: + + ```yaml + # ... + env: + - name: HOST_IP + valueFrom: + fieldRef: + fieldPath: status.hostIP + # ... + ``` + +5. Make sure that the [service pipelines][7] are using OTLP: + + ```yaml + # ... + service: + pipelines: + metrics: + receivers: [otlp] + processors: [resourcedetection, k8sattributes, batch] + exporters: [otlp] + traces: + receivers: [otlp] + processors: [resourcedetection, k8sattributes, batch] + exporters: [otlp] + # ... + ``` + + In this case, don't use the `hostmetrics` receiver because those metrics will be emitted by the Datadog Agent. + +[1]: /opentelemetry/otel_collector_datadog_exporter/?tab=kubernetesdaemonset#4-run-the-collector +[2]: /containers/kubernetes/ +[3]: /opentelemetry/otlp_ingest_in_the_agent/?tab=kubernetesdaemonset#enabling-otlp-ingestion-on-the-datadog-agent +[4]: https://github.com/open-telemetry/opentelemetry-collector/blob/main/exporter/otlpexporter/README.md#otlp-grpc-exporter +[5]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L15 +[6]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/daemonset.yaml#L33 +[7]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/2c32722e37f171bab247684e7c07e824429a8121/exporter/datadogexporter/examples/k8s-chart/configmap.yaml#L30-L39 +{{% /tab %}} +{{< /tabs >}} + +### Logs and traces correlation + +If you are using the Datadog Exporter to also send OpenTelemetry traces to Datadog, use the `trace_parser` operator to extract the `trace_id` from each trace and add it to the associated logs. Datadog automatically correlates the related logs and traces. See [Connect OpenTelemetry Traces and Logs][18] for more information. + +{{< img src="logs/log_collection/logs_traces_correlation.png" alt="The trace panel showing a list of logs correlated with the trace" style="width:70%;">}} + +### Host name resolution + +The host name that OpenTelemetry signals are tagged with is obtained based on the following sources in order, falling back to the next one if the current one is unavailable or invalid: + +1. From [resource attributes][19], for example `host.name` (many others are supported). +2. The `hostname` field in the exporter configuration. +3. Cloud provider API. +4. Kubernetes host name. +5. Fully qualified domain name. +6. Operating system host name. + +## Deployment-based limitations + +The OpenTelemetry Collector has [two primary deployment methods][20]: Agent and Gateway. Depending on your deployment method, some components are not available. + +| Deployment mode | Host metrics | Kubernetes orchestration metrics | Traces | Logs auto-ingestion | +| --- | --- | --- | --- | --- | +| as Gateway | | {{< X >}} | {{< X >}} | | +| as Agent | {{< X >}} | {{< X >}} | {{< X >}} | {{< X >}} | + +## Out-of-the-box dashboards + +Datadog provides out-of-the-box dashboards that you can copy and customize. To use Datadog's out-of-the-box OpenTelemetry dashboards: + +1. Install the [OpenTelemetry integration][21]. +2. Go to **Dashboards** > **Dashboards list** and search for `opentelemetry`: + + {{< img src="metrics/otel/dashboard.png" alt="The Dashboards list, showing two OpenTelemetry out-of-the-box dashboards: Host Metrics and Collector Metrics." style="width:80%;">}} + +The **Host Metrics** dashboard is for data collected from the [host metrics receiver][22]. The **Collector Metrics** dashboard is for any other types of metrics collected, depending on which [metrics receiver][23] you choose to enable. + + +### Containers overview dashboard + +
The Container Overview dashboard is in private beta. Fill out this form to try it out.
+ +
This feature is affected by Docker deprecation in Kubernetes and you might not be able to use dockerstatsreceiver for OpenTelemetry with Kubernetes version 1.24+.
+ +The [Docker Stats][24] receiver generates container metrics for the OpenTelemetry Collector. The Datadog Exporter translates container metrics to their Datadog counterparts. + +Use the following configuration to enable additional attributes on the Docker Stats receiver that populates the containers overview dashboard: + +```yaml + docker_stats: + metrics: + container.network.io.usage.rx_packets: + enabled: true + container.network.io.usage.tx_packets: + enabled: true + container.cpu.usage.system: + enabled: true + container.memory.rss: + enabled: true + container.blockio.io_serviced_recursive: + enabled: true + container.uptime: + enabled: true + container.memory.hierarchical_memory_limit: + enabled: true +``` + +The minimum required OpenTelemetry Collector version that supports this feature is v0.78.0. + +## Further Reading + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/datadogexporter +[2]: /tracing/other_telemetry/connect_logs_and_traces/opentelemetry +[3]: https://github.com/open-telemetry/opentelemetry-collector-releases/releases/latest +[4]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/datadogexporter/examples/ootb-ec2.yaml +[18]: /tracing/other_telemetry/connect_logs_and_traces/opentelemetry/?tab=python +[19]: https://opentelemetry.io/docs/reference/specification/resource/sdk/#sdk-provided-resource-attributes +[20]: https://opentelemetry.io/docs/collector/deployment/ +[21]: https://app.datadoghq.com/integrations/otel +[22]: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/hostmetricsreceiver +[23]: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver +[24]: https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/dockerstatsreceiver diff --git a/content/en/opentelemetry/collector_exporter/hostname_tagging.md b/content/en/opentelemetry/collector_exporter/hostname_tagging.md new file mode 100644 index 0000000000000..1f1f14279259c --- /dev/null +++ b/content/en/opentelemetry/collector_exporter/hostname_tagging.md @@ -0,0 +1,429 @@ +--- +title: Datadog Exporter Hostname and Tagging Configuration +further_reading: +- link: "/opentelemetry/collector_exporter/" + tag: "Documentation" + text: "OpenTelemetry Collector Datadog Exporter" +--- + +## Overview + +To extract the correct hostname and host tags, Datadog Exporter uses the Resource Detection and Kubernetes Attributes processors. These processors allow for extracting information from hosts and containers in the form of [resource semantic conventions][1], which is then used to build the hostname, host tags, and container tags. These tags enable automatic correlation among telemetry signals, and also tag-based navigation for filtering and grouping telemetry data within Datadog. + +For more information, see the OpenTelemetry project documentation for [Resource Detection][2] and [Kubernetes Attributes][3] processors. + +## Setup + +{{< tabs >}} +{{% tab "Host" %}} + +```yaml +processors: + resourcedetection: + # bare metal + detectors: [env, system] + system: + resource_attributes: + os.description: + enabled: true + host.arch: + enabled: true + host.cpu.vendor.id: + enabled: true + host.cpu.family: + enabled: true + host.cpu.model.id: + enabled: true + host.cpu.model.name: + enabled: true + host.cpu.stepping: + enabled: true + host.cpu.cache.l2.size: + enabled: true + # GCP + detectors: [env, gcp, system] + # AWS + detectors: [env, ecs, ec2, system] + # Azure + detectors: [env, azure, system] + timeout: 2s + override: false +``` + +{{% /tab %}} + +{{% tab "Kubernetes Daemonset" %}} + +In `values.yaml`: +```yaml +presets: + kubernetesAttributes: + enabled: true +``` + +Use the Helm `k8sattributes` preset, which sets up the service account necessary for `k8sattributesprocessor` to extract metadata from pods. Read [Important Components for Kubernetes][1] for additional information about the required service account. + +Collector configuration: +```yaml +processors: + k8sattributes: + passthrough: false + auth_type: "serviceAccount" + pod_association: + - sources: + - from: resource_attribute + name: k8s.pod.ip + extract: + metadata: + - k8s.pod.name + - k8s.pod.uid + - k8s.deployment.name + - k8s.node.name + - k8s.namespace.name + - k8s.pod.start_time + - k8s.replicaset.name + - k8s.replicaset.uid + - k8s.daemonset.name + - k8s.daemonset.uid + - k8s.job.name + - k8s.job.uid + - k8s.cronjob.name + - k8s.statefulset.name + - k8s.statefulset.uid + - container.image.name + - container.image.tag + - container.id + - k8s.container.name + - container.image.name + - container.image.tag + - container.id + labels: + - tag_name: kube_app_name + key: app.kubernetes.io/name + from: pod + - tag_name: kube_app_instance + key: app.kubernetes.io/instance + from: pod + - tag_name: kube_app_version + key: app.kubernetes.io/version + from: pod + - tag_name: kube_app_component + key: app.kubernetes.io/component + from: pod + - tag_name: kube_app_part_of + key: app.kubernetes.io/part-of + from: pod + - tag_name: kube_app_managed_by + key: app.kubernetes.io/managed-by + from: pod + resourcedetection: + # remove the ones that you do not use + detectors: [env, eks, ec2, aks, azure, gke, gce, system] + timeout: 2s + override: false +``` + +[1]: https://opentelemetry.io/docs/kubernetes/collector/components/#kubernetes-attributes-processor +{{% /tab %}} + +{{% tab "Kubernetes Daemonset -> Gateway" %}} + +In `values.yaml`: +```yaml +presets: + kubernetesAttributes: + enabled: true +``` + +Use the Helm `k8sattributes` preset in both Daemonset and Gateway, to set up the service account necessary for `k8sattributesprocessor` to extract metadata from pods. Read [Important Components for Kubernetes][1] for additional information about the required service account. + +Daemonset: + +```yaml +processors: + k8sattributes: + passthrough: true + auth_type: "serviceAccount" + resourcedetection: + detectors: [env, , , , system] + timeout: 2s + override: false +``` +Because the processor is in passthrough mode in the daemonset, it will add only the pod IP addresses. These will then be used by the Gateway processor to make Kubernetes API calls and extract metadata. + +Gateway: + +```yaml +processors: + k8sattributes: + passthrough: false + auth_type: "serviceAccount" + pod_association: + - sources: + - from: resource_attribute + name: k8s.pod.ip + extract: + metadata: + - k8s.pod.name + - k8s.pod.uid + - k8s.deployment.name + - k8s.node.name + - k8s.namespace.name + - k8s.pod.start_time + - k8s.replicaset.name + - k8s.replicaset.uid + - k8s.daemonset.name + - k8s.daemonset.uid + - k8s.job.name + - k8s.job.uid + - k8s.cronjob.name + - k8s.statefulset.name + - k8s.statefulset.uid + - container.image.name + - container.image.tag + - container.id + - k8s.container.name + - container.image.name + - container.image.tag + - container.id + labels: + - tag_name: kube_app_name + key: app.kubernetes.io/name + from: pod + - tag_name: kube_app_instance + key: app.kubernetes.io/instance + from: pod + - tag_name: kube_app_version + key: app.kubernetes.io/version + from: pod + - tag_name: kube_app_component + key: app.kubernetes.io/component + from: pod + - tag_name: kube_app_part_of + key: app.kubernetes.io/part-of + from: pod + - tag_name: kube_app_managed_by + key: app.kubernetes.io/managed-by + from: pod +``` + +[1]: https://opentelemetry.io/docs/kubernetes/collector/components/#kubernetes-attributes-processor +{{% /tab %}} +{{% tab "Kubernetes Gateway" %}} + +In `values.yaml`: + +```yaml +presets: + kubernetesAttributes: + enabled: true +``` +Use the Helm `k8sattributes` preset, which sets up the service account necessary for `k8sattributesprocessor` to extract metadata from pods. Read [Important Components for Kubernetes][1] for additional information about the required service account. + +Collector configuration: + +```yaml +processors: + k8sattributes: + passthrough: false + auth_type: "serviceAccount" + pod_association: + - sources: + - from: resource_attribute + name: k8s.pod.ip + extract: + metadata: + - k8s.pod.name + - k8s.pod.uid + - k8s.deployment.name + - k8s.node.name + - k8s.namespace.name + - k8s.pod.start_time + - k8s.replicaset.name + - k8s.replicaset.uid + - k8s.daemonset.name + - k8s.daemonset.uid + - k8s.job.name + - k8s.job.uid + - k8s.cronjob.name + - k8s.statefulset.name + - k8s.statefulset.uid + - container.image.name + - container.image.tag + - container.id + - k8s.container.name + - container.image.name + - container.image.tag + - container.id + labels: + - tag_name: kube_app_name + key: app.kubernetes.io/name + from: pod + - tag_name: kube_app_instance + key: app.kubernetes.io/instance + from: pod + - tag_name: kube_app_version + key: app.kubernetes.io/version + from: pod + - tag_name: kube_app_component + key: app.kubernetes.io/component + from: pod + - tag_name: kube_app_part_of + key: app.kubernetes.io/part-of + from: pod + - tag_name: kube_app_managed_by + key: app.kubernetes.io/managed-by + from: pod + resourcedetection: + detectors: [env, , , , system] + timeout: 2s + override: false +``` + +[1]: https://opentelemetry.io/docs/kubernetes/collector/components/#kubernetes-attributes-processor + +{{% /tab %}} +{{< /tabs >}} + +## Data collected + +| OpenTelemetry attribute | Datadog Tag | Processor | +|---|---|---| +| `host.arch` | | `resourcedetectionprocessor{system}` | +| `host.name` | | `resourcedetectionprocessor{system,gcp,ec2,azure}` | +| `host.id` | | `resourcedetectionprocessor{system,gcp,ec2,azure}` | +| `host.cpu.vendor.id` | | `resourcedetectionprocessor{system}` | +| `host.cpu.family` | | `resourcedetectionprocessor{system}` | +| `host.cpu.model.id` | | `resourcedetectionprocessor{system}` | +| `host.cpu.model.name` | | `resourcedetectionprocessor{system}` | +| `host.cpu.stepping` | | `resourcedetectionprocessor{system}` | +| `host.cpu.cache.l2.size` | | `resourcedetectionprocessor{system}` | +| `os.description` | | `resourcedetectionprocessor{system}` | +| `os.type` | | `resourcedetectionprocessor{system}` | +| `cloud.provider` | `cloud_provider` | `resourcedetectionprocessor{gcp,ec2,ecs,eks,azure,aks}` | +| `cloud.platform` | | `"resourcedetectionprocessor{gcp,ec2,ecs,eks,azure,aks}"` | +| `cloud.account.id` | | `"resourcedetectionprocessor{gcp,ec2,ecs,azure}"` | +| `cloud.region` | `region` | `resourcedetectionprocessor{gcp,ec2,ecs,azure}` | +| `cloud.availability_zone` | `zone` | `resourcedetectionprocessor{gcp,ec2,ecs}` | +| `host.type` | | `"resourcedetectionprocessor{gcp,ec2}"` | +| `gcp.gce.instance.hostname` | | `resourcedetectionprocessor{gcp}` | +| `gcp.gce.instance.name` | | `resourcedetectionprocessor{gcp}` | +| `k8s.cluster.name` | `kube_cluster_name` | `resourcedetectionprocessor{gcp,eks}` | +| `host.image.id` | | `resourcedetectionprocessor{ec2}` | +| `aws.ecs.cluster.arn` | `ecs_cluster_name` | `k8sattributes` | +| `aws.ecs.task.arn` | `task_arn` | `k8sattributes` | +| `aws.ecs.task.family` | `task_family` | `k8sattributes` | +| `aws.ecs.task.revision` | `task_version` | `k8sattributes` | +| `aws.ecs.launchtype` | | `k8sattributes` | +| `aws.log.group.names` | | `k8sattributes` | +| `aws.log.group.arns` | | `k8sattributes` | +| `aws.log.stream.names` | | `k8sattributes` | +| `aws.log.stream.arns` | | `k8sattributes` | +| `azure.vm.name` | | `k8sattributes` | +| `azure.vm.size` | | `k8sattributes` | +| `azure.vm.scaleset.name` | | `k8sattributes` | +| `azure.resourcegroup.name` | | `k8sattributes` | +| `k8s.cluster.uid` | | `k8sattributes` | +| `k8s.namespace.name` | `kube_namespace` | `k8sattributes` | +| `k8s.pod.name` | `pod_name` | `k8sattributes` | +| `k8s.pod.uid` | | `k8sattributes` | +| `k8s.pod.start_time` | | `k8sattributes` | +| `k8s.deployment.name` | `kube_deployment` | `k8sattributes` | +| `k8s.replicaset.name` | `kube_replica_set` | `k8sattributes` | +| `k8s.replicaset.uid` | | `k8sattributes` | +| `k8s.daemonset.name` | `kube_daemon_set` | `k8sattributes` | +| `k8s.daemonset.uid` | | `k8sattributes` | +| `k8s.statefulset.name` | `kube_stateful_set` | `k8sattributes` | +| `k8s.statefulset.uid` | | `k8sattributes` | +| `k8s.container.name` | `kube_container_name` | `k8sattributes` | +| `k8s.job.name` | `kube_job` | `k8sattributes` | +| `k8s.job.uid` | | `k8sattributes` | +| `k8s.cronjob.name` | `kube_cronjob` | `k8sattributes` | +| `k8s.node.name` | | `k8sattributes` | +| `container.id` | `container_id` | `k8sattributes` | +| `container.image.name` | `image_name` | `k8sattributes` | +| `container.image.tag` | `image_tag` | `k8sattributes` | + + +## Full example configuration + +For a full working example for EKS, see the Datadog Exporter example in [`k8s-values.yaml`][4]. + +## Example logging output + +``` +ResourceSpans #0 +Resource SchemaURL: https://opentelemetry.io/schemas/1.6.1 +Resource attributes: + -> container.id: Str(0cb82a1bf21466b4189414cf326683d653114c0f61994c73f78d1750b9fcdf06) + -> service.name: Str(cartservice) + -> service.instance.id: Str(5f35cd94-1b9c-47ff-bf45-50ac4a998a6b) + -> service.namespace: Str(opentelemetry-demo) + -> k8s.namespace.name: Str(otel-gateway) + -> k8s.node.name: Str(ip-192-168-61-208.ec2.internal) + -> k8s.pod.name: Str(opentelemetry-demo-cartservice-567765cd64-cbmwz) + -> deployment.environment: Str(otel-gateway) + -> k8s.pod.ip: Str(192.168.45.90) + -> telemetry.sdk.name: Str(opentelemetry) + -> telemetry.sdk.language: Str(dotnet) + -> telemetry.sdk.version: Str(1.5.1) + -> cloud.provider: Str(aws) + -> cloud.platform: Str(aws_ec2) + -> cloud.region: Str(us-east-1) + -> cloud.account.id: Str(601427279990) + -> cloud.availability_zone: Str(us-east-1c) + -> host.id: Str(i-09e82186d7d8d7c95) + -> host.image.id: Str(ami-06f28e19c3ba73ef7) + -> host.type: Str(m5.large) + -> host.name: Str(ip-192-168-50-0.ec2.internal) + -> os.type: Str(linux) + -> k8s.deployment.name: Str(opentelemetry-demo-cartservice) + -> kube_app_name: Str(opentelemetry-demo-cartservice) + -> k8s.replicaset.uid: Str(ddb3d058-6d6d-4423-aca9-0437c3688217) + -> k8s.replicaset.name: Str(opentelemetry-demo-cartservice-567765cd64) + -> kube_app_instance: Str(opentelemetry-demo) + -> kube_app_component: Str(cartservice) + -> k8s.pod.start_time: Str(2023-11-13T15:03:46Z) + -> k8s.pod.uid: Str(5f35cd94-1b9c-47ff-bf45-50ac4a998a6b) + -> k8s.container.name: Str(cartservice) + -> container.image.name: Str(601427279990.dkr.ecr.us-east-1.amazonaws.com/otel-demo) + -> container.image.tag: Str(v4615c8d7-cartservice) +ScopeSpans #0 +ScopeSpans SchemaURL: +InstrumentationScope Microsoft.AspNetCore +Span #0 + Trace ID : fc6794b53df7e44bab9dced42bdfbf7b + Parent ID : 2d3ba75ad6a6b1a0 + ID : f669b0fcd98365b9 + Name : oteldemo.CartService/AddItem + Kind : Server + Start time : 2023-11-20 13:37:11.2060978 +0000 UTC + End time : 2023-11-20 13:37:11.2084166 +0000 UTC + Status code : Unset + Status message : +Attributes: + -> net.host.name: Str(opentelemetry-demo-cartservice) + -> net.host.port: Int(8080) + -> http.method: Str(POST) + -> http.scheme: Str(http) + -> http.target: Str(/oteldemo.CartService/AddItem) + -> http.url: Str(http://opentelemetry-demo-cartservice:8080/oteldemo.CartService/AddItem) + -> http.flavor: Str(2.0) + -> http.user_agent: Str(grpc-node-js/1.8.14) + -> app.user.id: Str(e8521c8c-87a9-11ee-b20a-4eaeb9e6ddbc) + -> app.product.id: Str(LS4PSXUNUM) + -> app.product.quantity: Int(3) + -> http.status_code: Int(200) + -> rpc.system: Str(grpc) + -> net.peer.ip: Str(::ffff:192.168.36.112) + -> net.peer.port: Int(36654) + -> rpc.service: Str(oteldemo.CartService) + -> rpc.method: Str(AddItem) + -> rpc.grpc.status_code: Int(0) +``` + + +[1]: https://opentelemetry.io/docs/specs/semconv/resource/ +[2]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md +[3]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/k8sattributesprocessor/README.md +[4]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/datadogexporter/examples/k8s-chart/k8s-values.yaml From e16305740d5306a95e427ef6dfa0c9eacafb2e05 Mon Sep 17 00:00:00 2001 From: Kari Halsted Date: Tue, 12 Dec 2023 14:21:49 -0600 Subject: [PATCH 02/17] otlp --- .../collector_exporter/otlp_receiver.md | 189 ++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 content/en/opentelemetry/collector_exporter/otlp_receiver.md diff --git a/content/en/opentelemetry/collector_exporter/otlp_receiver.md b/content/en/opentelemetry/collector_exporter/otlp_receiver.md new file mode 100644 index 0000000000000..0599c7d1ead3d --- /dev/null +++ b/content/en/opentelemetry/collector_exporter/otlp_receiver.md @@ -0,0 +1,189 @@ +--- +title: Datadog Exporter OTLP Receiver +further_reading: +- link: "/opentelemetry/collector_exporter/" + tag: "Documentation" + text: "OpenTelemetry Collector Datadog Exporter" +--- + +## Overview + +The OTLP Receiver enables receiving OTLP metrics, logs, and traces. + +For more information, see the OpenTelemetry project documentation for the [OTLP Receiver][1]. + +## Setup + +```yaml +receivers: + otlp: + protocols: + http: + endpoint: "localhost:4318" + grpc: + endpoint: "localhost:4317" +``` + +## Data collected + +Traces, metrics, and logs. + +## Full example configuration + +For a full working example, see the Datadog Exporter example in [`otlp.yaml`][2]. + +## Example logging output + +``` +ResourceSpans #0 +Resource SchemaURL: https://opentelemetry.io/schemas/1.6.1 +Resource attributes: + -> k8s.node.name: Str(ip-192-168-61-208.ec2.internal) + -> process.command_args: Slice(["/app/shippingservice"]) + -> k8s.namespace.name: Str(otel-gateway) + -> process.pid: Int(1) + -> service.name: Str(shippingservice) + -> service.namespace: Str(opentelemetry-demo) + -> os.type: Str(linux) + -> k8s.pod.ip: Str(192.168.57.77) + -> deployment.environment: Str(otel-gateway) + -> service.instance.id: Str(82323d5f-0e47-4ae6-92b6-583dc1fa33a1) + -> k8s.pod.name: Str(opentelemetry-demo-shippingservice-7f9b565549-4p2pj) + -> cloud.provider: Str(aws) + -> cloud.platform: Str(aws_ec2) + -> cloud.region: Str(us-east-1) + -> cloud.account.id: Str(601427279990) + -> cloud.availability_zone: Str(us-east-1c) + -> host.id: Str(i-0e0b580bbe11883dc) + -> host.image.id: Str(ami-06f28e19c3ba73ef7) + -> host.type: Str(m5.large) + -> host.name: Str(ip-192-168-61-208.ec2.internal) + -> k8s.pod.start_time: Str(2023-11-13T15:03:50Z) + -> k8s.replicaset.uid: Str(537d3c30-fe3d-4999-be1a-51227c90a5e4) + -> kube_app_name: Str(opentelemetry-demo-shippingservice) + -> kube_app_instance: Str(opentelemetry-demo) + -> k8s.pod.uid: Str(82323d5f-0e47-4ae6-92b6-583dc1fa33a1) + -> k8s.replicaset.name: Str(opentelemetry-demo-shippingservice-7f9b565549) + -> kube_app_component: Str(shippingservice) +ScopeSpans #0 +ScopeSpans SchemaURL: +InstrumentationScope opentelemetry-otlp 0.11.0 +Span #0 + Trace ID : c4f6d4a8831a5d7b95727da5443ad8a4 + Parent ID : c7e98372030f17b1 + ID : f226428843050d12 + Name : reqwest-http-client + Kind : Client + Start time : 2023-11-20 12:56:26.401728438 +0000 UTC + End time : 2023-11-20 12:56:26.403518138 +0000 UTC + Status code : Unset + Status message : +Attributes: + -> http.host: Str(opentelemetry-demo-quoteservice) + -> http.url: Str(http://opentelemetry-demo-quoteservice:8080/getquote) + -> http.status_code: Int(200) + -> thread.name: Str(tokio-runtime-worker) + -> busy_ns: Int(199789) + -> code.namespace: Str(reqwest_tracing::reqwest_otel_span_builder) + -> code.lineno: Int(128) + -> thread.id: Int(3) + -> http.method: Str(POST) + -> http.user_agent: Str() + -> idle_ns: Int(1588692) + -> code.filepath: Str(/usr/local/cargo/registry/src/github.com-1ecc6299db9ec823/reqwest-tracing-0.4.0/src/reqwest_otel_span_builder.rs) + -> net.host.port: Str(8080) + -> http.scheme: Str(http) +ResourceMetrics #0 +Resource SchemaURL: https://opentelemetry.io/schemas/1.6.1 +Resource attributes: + -> service.name: Str(opentelemetry-collector) + -> net.host.name: Str(192.168.38.72) + -> service.instance.id: Str(192.168.38.72:8888) + -> net.host.port: Str(8888) + -> http.scheme: Str(http) + -> k8s.pod.ip: Str(192.168.38.72) + -> cloud.provider: Str(aws) + -> cloud.platform: Str(aws_ec2) + -> cloud.region: Str(us-east-1) + -> cloud.account.id: Str(601427279990) + -> cloud.availability_zone: Str(us-east-1c) + -> host.id: Str(i-0fb30793f89bd81ab) + -> host.image.id: Str(ami-0cbbb5a8c6f670bb6) + -> host.type: Str(m5.large) + -> host.name: Str(ip-192-168-37-51.ec2.internal) + -> os.type: Str(linux) + -> k8s.pod.uid: Str(01f039fa-abf3-4ab1-8683-923dcf94b391) + -> k8s.namespace.name: Str(otel-ds-gateway) + -> k8s.pod.start_time: Str(2023-11-20T12:53:40Z) + -> k8s.daemonset.uid: Str(694b994d-3488-418a-9f94-284792f1f8da) + -> k8s.daemonset.name: Str(opentelemetry-collector-agent) + -> k8s.node.name: Str(ip-192-168-37-51.ec2.internal) + -> kube_app_name: Str(opentelemetry-collector) + -> kube_app_instance: Str(opentelemetry-collector) + -> k8s.pod.name: Str(opentelemetry-collector-agent-4dm92) +ScopeMetrics #0 +ScopeMetrics SchemaURL: +InstrumentationScope otelcol/prometheusreceiver 0.88.0-dev +Metric #0 +Descriptor: + -> Name: otelcol_exporter_queue_capacity + -> Description: Fixed capacity of the retry queue (in batches) + -> Unit: + -> DataType: Gauge +NumberDataPoints #0 +Data point attributes: + -> exporter: Str(otlp) + -> service_instance_id: Str(ab73126a-0eff-4678-922d-a96b1fdabcdc) + -> service_name: Str(otelcontribcol) + -> service_version: Str(0.88.0-dev) +StartTimestamp: 1970-01-01 00:00:00 +0000 UTC +Timestamp: 2023-11-20 13:01:26.074 +0000 UTC +Value: 1000.000000 + +ResourceLog #0 +Resource SchemaURL: https://opentelemetry.io/schemas/1.6.1 +Resource attributes: + -> k8s.container.name: Str(loadgenerator) + -> k8s.namespace.name: Str(otel-staging) + -> k8s.pod.name: Str(opentelemetry-demo-loadgenerator-d8c4d699d-ztt98) + -> k8s.container.restart_count: Str(1) + -> k8s.pod.uid: Str(92bf09ed-0db9-4f69-a9d6-1dadf12e01aa) + -> k8s.pod.ip: Str(192.168.55.78) + -> cloud.provider: Str(aws) + -> cloud.platform: Str(aws_ec2) + -> cloud.region: Str(us-east-1) + -> cloud.account.id: Str(601427279990) + -> cloud.availability_zone: Str(us-east-1c) + -> host.id: Str(i-0368add8e328c28f7) + -> host.image.id: Str(ami-08a2e6a8e82737230) + -> host.type: Str(m5.large) + -> host.name: Str(ip-192-168-53-115.ec2.internal) + -> os.type: Str(linux) + -> k8s.daemonset.uid: Str(6d6fef61-d4c7-4226-9b7b-7d6b893cb31d) + -> k8s.daemonset.name: Str(opentelemetry-collector-agent) + -> k8s.node.name: Str(ip-192-168-53-115.ec2.internal) + -> kube_app_name: Str(opentelemetry-collector) + -> kube_app_instance: Str(opentelemetry-collector) + -> k8s.pod.start_time: Str(2023-11-20T12:53:23Z) +ScopeLogs #0 +ScopeLogs SchemaURL: +InstrumentationScope +LogRecord #0 +ObservedTimestamp: 2023-11-20 13:02:04.332021519 +0000 UTC +Timestamp: 2023-11-20 13:01:46.095736502 +0000 UTC +SeverityText: +SeverityNumber: Unspecified(0) +Body: Str( return wrapped_send(self, request, **kwargs)) +Attributes: + -> log.file.path: Str(/var/log/pods/otel-staging_opentelemetry-demo-loadgenerator-d8c4d699d-ztt98_92bf09ed-0db9-4f69-a9d6-1dadf12e01aa/loadgenerator/1.log) + -> time: Str(2023-11-20T13:01:46.095736502Z) + -> logtag: Str(F) + -> log.iostream: Str(stderr) +Trace ID: +Span ID: +Flags: 0 +``` + + +[1]: https://github.com/open-telemetry/opentelemetry-collector/blob/main/receiver/otlpreceiver/README.md +[2]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/datadogexporter/examples/otlp.yaml \ No newline at end of file From 473700207b3501bde713d0f17210a7c32e5244a7 Mon Sep 17 00:00:00 2001 From: Kari Halsted Date: Tue, 12 Dec 2023 14:42:19 -0600 Subject: [PATCH 03/17] host metrics --- .../collector_exporter/_index.md | 2 +- .../collector_exporter/host_metrics.md | 146 ++++++++++++++++++ .../collector_exporter/hostname_tagging.md | 2 + .../collector_exporter/host_metrics.png | Bin 0 -> 906057 bytes .../collector_exporter/hostname_tagging.png | Bin 0 -> 380590 bytes 5 files changed, 149 insertions(+), 1 deletion(-) create mode 100644 content/en/opentelemetry/collector_exporter/host_metrics.md create mode 100644 static/images/opentelemetry/collector_exporter/host_metrics.png create mode 100644 static/images/opentelemetry/collector_exporter/hostname_tagging.png diff --git a/content/en/opentelemetry/collector_exporter/_index.md b/content/en/opentelemetry/collector_exporter/_index.md index 9a75b2526e3e5..e5bfd974279de 100644 --- a/content/en/opentelemetry/collector_exporter/_index.md +++ b/content/en/opentelemetry/collector_exporter/_index.md @@ -462,7 +462,7 @@ The host name that OpenTelemetry signals are tagged with is obtained based on th ## Deployment-based limitations -The OpenTelemetry Collector has [two primary deployment methods][20]: Agent and Gateway. Depending on your deployment method, some components are not available. +The OpenTelemetry Collector has [two primary deployment methods][20]: Agent and Gateway. Depending on your deployment method, the following components are available: | Deployment mode | Host metrics | Kubernetes orchestration metrics | Traces | Logs auto-ingestion | | --- | --- | --- | --- | --- | diff --git a/content/en/opentelemetry/collector_exporter/host_metrics.md b/content/en/opentelemetry/collector_exporter/host_metrics.md new file mode 100644 index 0000000000000..d725ea57f03b6 --- /dev/null +++ b/content/en/opentelemetry/collector_exporter/host_metrics.md @@ -0,0 +1,146 @@ +--- +title: Datadog Exporter Host Metrics Configuration +further_reading: +- link: "/opentelemetry/collector_exporter/" + tag: "Documentation" + text: "OpenTelemetry Collector Datadog Exporter" +--- + +## Overview + +{{< img src="/opentelemetry/collector_exporter/host_metrics.png" alt="OpenTelemetry host metrics dashboard" style="width:100%;" >}} + +The host metrics receiver enables collecting system metrics such as CPU, disk, and memory usage. + +For more information, including supported operating systems, see the OpenTelemetry project documentation for [the Host Metrics Receiver][1]. + + +## Setup + +{{< tabs >}} +{{% tab "Host" %}} + +```yaml +receivers: + hostmetrics: + collection_interval: 10s + scrapers: + paging: + metrics: + system.paging.utilization: + enabled: true + cpu: + metrics: + system.cpu.utilization: + enabled: true + disk: + filesystem: + metrics: + system.filesystem.utilization: + enabled: true + load: + memory: + network: + processes: +``` + +{{% /tab %}} + +{{% tab "Kubernetes" %}} + +Set up the host metrics receiver up on each node from which metrics need to be collected. This means that to collect host metrics from every node in your cluster, deploy the host metrics receiver as a daemonset collector: + +```yaml +receivers: + hostmetrics: + collection_interval: 10s + scrapers: + paging: + metrics: + system.paging.utilization: + enabled: true + cpu: + metrics: + system.cpu.utilization: + enabled: true + system.cpu.physical.count: + enabled: true + system.cpu.logical.count: + enabled: true + system.cpu.frequency: + enabled: true + disk: + filesystem: + metrics: + system.filesystem.utilization: + enabled: true + load: + memory: + network: + processes: + +``` + +{{% /tab %}} + +{{< /tabs >}} + +## Data collected + +See [OpenTelemetry Metrics Mapping][2] for information about collected host metrics. + + +## Full example configuration + +For a full working example, see the Datadog Exporter example in [`host-metrics.yaml`][3]. + +## Example logging output + +``` +ResourceMetrics #1 +Resource SchemaURL: https://opentelemetry.io/schemas/1.9.0 +Resource attributes: + -> k8s.pod.ip: Str(192.168.63.232) + -> cloud.provider: Str(aws) + -> cloud.platform: Str(aws_ec2) + -> cloud.region: Str(us-east-1) + -> cloud.account.id: Str(601427279990) + -> cloud.availability_zone: Str(us-east-1c) + -> host.id: Str(i-07e7d48cedbec9e86) + -> host.image.id: Str(ami-0cbbb5a8c6f670bb6) + -> host.type: Str(m5.large) + -> host.name: Str(ip-192-168-49-157.ec2.internal) + -> os.type: Str(linux) + -> kube_app_instance: Str(opentelemetry-collector-gateway) + -> k8s.pod.name: Str(opentelemetry-collector-gateway-688585b95-l2lds) + -> k8s.pod.uid: Str(d8063a97-f48f-4e9e-b180-8c78a56d0a37) + -> k8s.replicaset.uid: Str(9e2d5331-f763-43a3-b0be-9d89c0eaf0cd) + -> k8s.replicaset.name: Str(opentelemetry-collector-gateway-688585b95) + -> k8s.deployment.name: Str(opentelemetry-collector-gateway) + -> kube_app_name: Str(opentelemetry-collector) + -> k8s.namespace.name: Str(otel-ds-gateway) + -> k8s.pod.start_time: Str(2023-11-20T12:53:08Z) + -> k8s.node.name: Str(ip-192-168-49-157.ec2.internal) +ScopeMetrics #0 +ScopeMetrics SchemaURL: +InstrumentationScope otelcol/hostmetricsreceiver/memory 0.88.0-dev +Metric #0 +Descriptor: + -> Name: system.memory.usage + -> Description: Bytes of memory in use. + -> Unit: By + -> DataType: Sum + -> IsMonotonic: false + -> AggregationTemporality: Cumulative +NumberDataPoints #0 +Data point attributes: + -> state: Str(used) +StartTimestamp: 2023-08-21 13:45:37 +0000 UTC +Timestamp: 2023-11-20 13:04:19.489045896 +0000 UTC +Value: 1153183744 +``` + + +[1]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/hostmetricsreceiver/README.md +[2]: https://docs.datadoghq.com/opentelemetry/guide/metrics_mapping/#host-metrics +[3]: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/datadogexporter/examples/host-metrics.yaml \ No newline at end of file diff --git a/content/en/opentelemetry/collector_exporter/hostname_tagging.md b/content/en/opentelemetry/collector_exporter/hostname_tagging.md index 1f1f14279259c..f04d7576378e5 100644 --- a/content/en/opentelemetry/collector_exporter/hostname_tagging.md +++ b/content/en/opentelemetry/collector_exporter/hostname_tagging.md @@ -6,6 +6,8 @@ further_reading: text: "OpenTelemetry Collector Datadog Exporter" --- +{{< img src="opentelemetry/collector_exporter/hostname_tagging.png" alt="Hostname information collected from OpenTelemetry" style="width:100%;" >}} + ## Overview To extract the correct hostname and host tags, Datadog Exporter uses the Resource Detection and Kubernetes Attributes processors. These processors allow for extracting information from hosts and containers in the form of [resource semantic conventions][1], which is then used to build the hostname, host tags, and container tags. These tags enable automatic correlation among telemetry signals, and also tag-based navigation for filtering and grouping telemetry data within Datadog. diff --git a/static/images/opentelemetry/collector_exporter/host_metrics.png b/static/images/opentelemetry/collector_exporter/host_metrics.png new file mode 100644 index 0000000000000000000000000000000000000000..6c7e16d38c77a4a2b6082553d2f0e916275408f5 GIT binary patch literal 906057 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

DSAH3|=}XhG`!~&7fta38BE*$KP5sfTR-+ zX3lDr7w$CO+&}L*r3IwRlr~%>2Eds4zn18G9j`Tgs3MRLMI)J$&Okk!`HQ$=DVEmj zbDJkjnrYzF^k*THeYKNc)O|Mf>M!1}>7LH#GD^TLk-kGUQX&hlhkc3{X%&@0pf(vH zmEaE|r3Mm%U@eMZ39Ybr#f={A@SLYPmS1NmYoiIG_io zA^v%*%ex1tahJCdGRJ(m7YKzk5RqHkdv8KtZT4$CXPc;1989Rb%F}W~cqr`_onmK; zWp{Ly;z?^WT3?`2y@?A?47i-4u*U zJMIl@`cC0@{O3v~_c>a}c-s&h5S%7_Z=y6V%%vZs@%wkW%V*||g+48-&hy`!SAf@E z721`m^ZbCO!#92b5VfmPmrw8u-(POy6uyPJc^VSd9f*YM#>(`rFnK>v?kc)1P0J8H z(q<)Wr+}ioKveP9xuncvcs5sGF=i1h`_TINNsR!8%*tQNLPRTz1;sZ9=7#Dk(>wTKI@mEL9xEu9IACWNf{ej2 zdkpWY+qar-(j&`W?fe66!O45o+R&E!@mvaPWc7gvmvHP&?ec@C4W-Z18PG!e0@h_Z zMj)MkdB=>-=Xtnvj846!u{EA&r&`0N9?N+OnSoOriIKw;4j|MTwrPs6m7PWo;KL3x z6dQqXxz@jwS`sVDp$Qf96!!I?onMZ!H+43>-ur|ilcanT)1-YBkrI>e9k?oJPAeVK zOIAJgo+h2P1U@r8|L~xE?m2sHxkBqYM@zM=qap<`LV<0Z`PmtjmP;u!DFF0Vd#9hZKPJCr(Ko>=OexLDfA9A4ck~)5s`G2hr*9(73^As`}rfgN`zq zm2AgB$nL@^E=6bIO!UVyQAgEXFUwa8g>eT#dzn{fe&_2}-gEUNPBcM^Y8uN(=-u^<->Lk;IqwjfC$8;^ZLHu z@!zLd&Yfht_qXanM4*Cc5i~<`_p>$IqMhL(;#@RSiUl@W5Eum5!){eE28P9edfphi zBupq}dr%SII1o`RRXA05x@^IxqA&*4R6Vn2BaV5jmkq3?rO6cr+b!c-IEg{NR7_gV zTXjG>j|l~WvcIS^`Pi2ab%R3A$t>jGh~U!I==UmWJBweEuPcn6%W?L`3_M}hqs%=J z+EC~zD3?(hqma>c(@V|SarArA+H}`F21NABl~7nM*IWH0D7~b0i#k!fChPfC_c%-@oKsJSTg1us~K+da2 z;|)cM86CD|Sgv~%*JgH6Kez3&_Y+7ji`&_yh6oODJz_ny%er=}?9G?7Mz3N^=1&() zNYinUGrVHh8_(`` zK>bq7nlxF%y`kl$oom-mp_Z9JK+m08CMQm!pP*@(ZR^ka;=Z6*kfmhd-o?d0nIhrd zXq0DRd%y=Tv%naBSUmvzg3;Rmh76~3+(pn$aYr{gt9|>0%&*gJwC70B>jygfRqA3# z#ICn^CZ8aZ$m6w0Td%RP_txj^c4@)ik^J&j(~*0gr7J(*WISM$+faXeee^J=O=oX{ zsrSQ6TuW9$x-;bv+F&wiCydP!AM$cly*g09P?8IQebhW)f1!KfNbwhqy3J10jQF#0 z;CqY(l5&zl^JwGjfao zZ81#jY4hrhp}W#p?tnI~h&%o`5 zaW6k`7%DU1Ou|b@JOc0lJnhLS=x*9tl52(L&<3%`hMW3@d?Eyna<4{0P6RBDoU_@D z-y3tZM>0t4h7@3dN!-8w=!xigGYP!k;48II#qEQBVA9i5-pa66`^8J77qp8TPl|6J zNVJ)B=RpUe90$l7p@gnPB)p}!|Y7v8O3*&K>-Yw~RKf%#n0 z^>WnJ94Di{b1qrXZ#Kv$QBKpO7H`fd|_H)gG172!NfJPl^$Lrp!fc zByvP)#4rOKnQ}TvZWW5&zmXZU)Zp466ZhBwGg8yB{JkBc{~|s|nx%el!5C^>M+Tn5 zM!kA<-Fn@aNOo>Wh`#r~7Zh~b2_FduuUnWL0{YUd5V``oIj?WlaqYMSC0QA`f+^rnD??5(SAw!N!~i2A=o zpkq9QL>RJj;sxH`+P15iI$EzYD$g38t4D^G+X%Pa8BTbN0zN4}7rV8STw~k9N`u;W zk{j^7{u8)xynJ*Y@R6EhNU8mB#Nm2B}%CSN|@Fk*4II7m+8yK}aF zeTZ4V!w{`-Ri6QPECw&T6qQ`c#80Lv zz;PknfaDx3LO4^zdvzoJxmSq_?5cTKt6RsD_yH(QSZsI^`%?N{uh>)X!OgN^7E;)b zf`QdkZoCdBt>03ZuQ=%SO68T83M)DHBIHF%Y>A~9VL)e%O1o~_ZbNzH@vLk8;Z49b zjL3TRGsVuhpSLPUnaN#7M@cd&GFH-XT;u$Ni1>xNDj>b2y-Pt96hsG z;OS&N{tbl1_l#eVMWcR}t&d|d{X-vGh`YXBX?U3c#)ku5~< zwOq?L>)`zq$J?%Y8FBb3Qo42}<{&k9^M=dcX4_8evb2I*P>8pAu+%MmB@9eg}< z-&0AqG&c1Ob_Q<)cTHYGEi<5$N_&Cnq*p=`Q?!`S{1r>PnC=waZ5G@aV7OUAHhR0vXS1_O}OI+WIF7nwn;&lO_Zi%idjbKdLEK(=8$6c7}l5 z++CeR1z!$g(tOP8<1PZS~$o_A}4^~dO-or`z8IVgM zwo7qvYnXQezoY!}<2zT6(X%2J)rDF6L4Q|JSvtBPCL&T(6x$4>;xP_kk?8E9p_(fmJP_(jDTo zC4}%N+kHz@R72%5w9)U?M!$SZ!r^=2>77{%hp&O-0G^hZ%6McX%ST>!6(KHhI&&jo z65@ifpv!k-7XvX)TGhVNz?lFqgppt7qlCXEgv>2yD9?uIePFZG@MaK*9jl8>1TU!} zR1@P$kLUr_+7A%MaGY$<)N>-S@{T-ZjDCK$3^qd*jf1@^-R2u_kdLN!kDYBLy?O_} z3h}r8jjJ&e;_JwGaCv#>Aq$8HI2xVi{E^#oZ_&$CVYkQHNwwXmOvky?sm$*a(l4Lq z$LZ<&{g5WJ0^6V}Sujhr;`pVo?>Qq`80&_)KN^u9V`CA68--F*9N_cPxjlEm>=ZS| zC9}hMdOK#tlZwc7ph*Og*`eGs7C9+z&=5bdqg&0Y9nyFha@cN(PnzH=k*j}g}=EYY{pZad?4Z?JZII6=%VwH=pb*L(z(C^_Pg&uTU(K>DVlH*p|;nP)92sG7Q`$aB=XMUfFK^wC;6uyi8D zlyZ*l0saW|D}-U`-M69*q=4tQ@?53V%O>C@KZSG)OO0R(dlyESl6_pjZpEyRkQ{T1 zOi}F+WjLz#Jkft8^l4*p{q=cW02k>pwuf{a+@cT^dCfT1Q3F0pwHS2w-FJWEUVIKs z59r$h8IGZwB_k(h^o+=x0K|R73&BGWeCv#P!*7idSPp%q6cq2Z?>#n2f~XMaZPAA@ zapLG0T?01)?!Gz%KfNlp>04spU*?_aTRLp^4~zFY?+oV+Z+y%|K(XFIoabO9G!8&D z#8#Tg>JEdqN+|V9b{IFpFG4gyy3t5AJ(M;~4y!+(qU5Y~h^|z_1frB#cX_M0xHjv6 zd^eDNyDv?0-X9{}oMwi`VPBS1br?1hUt*d>7Qox?^qqLEK`Cfrg+K&Z8ahu>Qs@JLM-J0l}rFz zC4=YAmJiyKmI*Yq<~(HAPX0qh-i=~T@D9NxH^gs^2 zrKrXP)JnViTJKyDH2+^|CSec6ee8g|)-aQ37*o07+`EX}+IqY+Pu#bQ<)~hod??NO z3r3>!wE=ME?mhLoo?Tmi?LOTSr4vC$;gc~ef8X%FXVu!&9|f^1DKWF__BU;*<3Tj1 z(}4Xu)n3`RsUS=Y;i{<}skXqIu%VYe2A~N7v#abc=cuJP(-9@z4cNBm5FXgyY2r(6 zDn3YKR-<*91OjH4aj$oAS%FBGclmEEguuwZ718pHK9g%R5s!?`oIro#g{xtLce@?e zb9yK6xxhd1L=i?bW5c9vk|hrLQaT^5xXBXR{iNT~N*DJ)jVlAcqo*JhKFqs!T>p~J zT(1V;Xf4YU-)BYt==#^o*O+i0{roQtN1Jh)T6*%@ub-aY{4^dGz&6^6T!-ps@ju}g z!Qwig*tiGxjw6GTu}QW#hLGQcy+eaMQ&q|>y54M!Qd}p%-5t;aJ9VGnpLwyb_xTu6 zfe@9K9hDNX`y?^0r=Dn$e-&{}ITa}Bm@3X+#8FX-6Wu$ZIX5EQXcrhaMOb#x+gE7G zL_=9WRryb+k-wSl#ERVcZ^|+%z#J1lcKf@0)0=197oPV>Z5CebS!zmUJa`o19$Jvd zYyXeQZsQ9S&V7lETmG(J85IHk()oa?C};?rv+)=kr)76GG4#7{%=!s`O`%Ih8Womr zFJ7D}{}yhT5Y|M-uM6?azS8Iw)3^3DWH5v6USlgnbjwp$pF#X8ksV5y{Ab@($dV$N zH+zQ;IM2l3N{_`qp~dZw>{>*T90H<%yLLsdE$^ocagq{-qF*C&aGGEuMjyeaC$I;& zgsVIoP!-Mzro^UQ`_Ked0-!vk_x=gR^}*Ky7O3rzWt12 zSzYow?JZ^{R!3BQQ{s_cSxm?kU~iX8--H4mK7%~d*)AE!T%MFoN~etIpgsXP9keQR zTR&&ifUdO>XYxZhZgdg{Sg3Qp4X@p1GY%O6JuS zD}vV@yf2s5OieLpmn};+^^w2rto{I^hWQ|3<&jGtBSCBm`hXkO?YfkClYiW|*=9#P z?i6?Ly4OCOCG`9jPFkzm14cfP#>|^VG@CN1FSSW{#iCv%W&FAm3G-|TTGj{caT3}C2Mg&1<_%D3HPXg_-=N( zycR|;>kfE$etaL%h3CiYgOlVQ^HNsjlk$+-PC@ixS^x}E20MDG%bUu6*&ZrFK$$;H zc?a!e{$hKt-P-M)WG3rW^d7+e}f9vmm1r2G|zwjnf#$t zoH3bBNhr01QdL$()0^RzVjKybdPD51$!6V2gNE(q(|M_DP)*g`n1+Vxq*vhA-g@AG z$s|`pwXKO|^{gXkCsw>x=$UG5P$dhTb;{j@Z2eo6UK(g8wt&Pk!R*ABLgLw}a;=i| zyvz3i)gJ!xG^||ht+%Y)`Sc0zD&b@G^jBh~v?Y+F@TqOExhf^RCQ7cI%zaAR)I%xz z6Vn3#TClCCZn4YtTF7+@Wq%^6S#E|z{9Me$`_yx9q^#Nzrys#HP33eQUr!Ese*hV1 zG;ta|7l-Ivlp(vspHsf69u=XG#(Cd<1izh{VNUwmMmyTWp-A(Ju%$ZNJ`~0r(S1is4udK&srIZC8KJhV!G0BrZ8<6aH@f>jCLX zAoz*&nK$}JSX)tx@XjZ~^@r56S}e3VPl?g*W-jeFm*W{(*8-iJ%j3QNzk-lZQEbev z!~FiPGw4r?T@KM$^o%1T!bX`^f~ZnKCi0&?X*d#HzCNwLrs)iBnFqv3WY=?{d`21> zg&Jx$+H`Bc|l(SYIm#oHa5kBRt5zWH2+Rl<~mR8y?(PDM@9jBZ;z&Ay*Ca< zFO9*bnd&CLiF-|NXK8#siR)*LQNfHZ+*949YVdlk?559Ko-vwkTgZ?rPVa12Ip1 zj^A}I0V{d0E$fd4&;gi$Q@}I!{?o>WX~gdP?qG8+Pc2uytc^o*t-VUy({0oojhm4{O#5>zCC3pSdDVkIX{%MidOzW(c**IkPlVjC3B@1E@T zvjv^~dc7!COzko(>p}O&EkI`rWkOKqF%v_N-z${NxxEPT6p=Q%f1EC`l`doezBS!b zViemoiw$*=Pr5_MJ*!P3xRcUhgm-2mYe2?3gi(I~(I1k^re~pmj5&k#b#WAn!p3*P zr}is^FSbmq=awu8Bfw)UEuoZ!?CvQJZ={a~3%oB>t*$v`0dGCB2R-bwv`fF6fjuru z!`p8}bwn*vBwmN!4+72blABMNhR|s+=)m%(ESzjK+`lT z6lb->E4?RG6W(&+Bu$lZTS4pZaSHOrIeT_BgmuvuqvhZ)^?hF!Gk$4!?nq@KK$1*3 z-JTeE%!}D$ksT-8^2js^B@UgV&l$%Qf0ykviqO5UPi7*+g|!RkHZ?;%+t5e7-J9!Q z4)tQx!j8upME=x1K7`x`$Fnq;!X$@xpHKdcV<(k=Psd(wLMfo2*^K9;TlcRAY98O> zXS=-ip}%>l^X3y*lH>5xsY4UxUpnY58A-WrKecO)zlGi9H$OSg^!~_fknB?0Wtq(% z^@<)!i89q7KVZ*C#IbtZw?Xa`;SD57i-gL=V|tS;Wr+jWt&MV=RL#Q}Qi|rkmPBIy z>Swu$@&>losF-UQm2ZF~Bax|V5lfe(74f3P;+xW!bmlIVxF?bYPEk=uTU!^cnqU>{ zGDC(mkgq1PXKI)H$GgHFL?&Eoy2mDi~^+JWTXl)i79(utfwZEM<};$!tp6lq(O1rOWtN4j2Ne@X~Iow&qW?{T*W%y zQu9k&WzFnA*CSdMB=GRBon!fL*jAbfm{wj3xyhn4e zk?%vT9V@@EJbi=4j*H4V{$p--3OM<*i+Ue~u7rLe#s@otxNE}TLLx(0G|Zh)l6|UF zfk&`2@28dsi~jAW$NL0D|2aY{i*Q!@Nk<0)t~|^!S)`m!gC(5Gw16yUB)Hdac`tdw zWk`K79E7v2*U!a94|F)%Y315qrcnZD^J%v1vhVa6Hu$rsq4hR6RAS6iMD0(zl4K)6 zd6IjJ;^oNL%rwT*bG+fi>eu*KTJwyI=Ng2VWP;yxgRT!$F}FNKkhD-tk#G%b^#_@k z;7`k$c;XY0gSbz|#rr4^IXp+;iI2>of)yW=XOR!(4CK+g+r$_Hqua@~4)tHj4xDNl z)UAckI4(=btxx5i76h&!G^3Byq z^TRA&saS-(^bI{kaIVn37#=Hb|36}HKm2FBf2(ts%(XkP7zTI=8Vs8Q| zZ&>+Pv!%Liiz+B9i1)Y7g0=sKbZ==;7y6Ub@NU3UH~HmKP#4PIxFH4zR4qRz0d~n* z?jsck78ucJhq!>WN;D36;^aghqA$vK6v9Wfl?j81p#R0)HNTA(gQ;y)VvSgC`QsV| z4rpQ!<4Bc8PoIGUhz>Fd;<-HF;JSq8x!ecNKVC^1qlU_x$a&#(FG5S%YX2H^`Btq; zm6UbGNi|w(QtV{KEmkI>V_5=TPfn_slYj#n><=Gc(eD^{C}8y&(@KXI2EvdapEVum zZGoI9YXXd6r9G~Lkx$_e8PUBFS|?>v9EhJsJdrlYa|NEGxzccP5V>CA0|vTT_56JG zpZDd>s+uFRr@b0>SXVA`P$bdbg*EE_@I?H$nWQRPxvaWI19ol357%(;=af|zD0VT( z`lVttx6#)6QWK07w*-e$l*2fn=h{xH_5-7hkL2Fjv=q;Js0R~{+F0n^ydy0n7j#6?Dzia6b-Y$JqCu4l>y}D0UlLYc-#{`xH%oB8_?oP zKTM&~21Dc#Igy)Krom2CH-51i$dL_MQVTLm;hxw<5xPvqvAKIhs0XLmu zDiyJLohrZa@Zdpl+!L}d>Q6A=(0<8NzjfPVQ^H0&Iu`TO3DL1tR%bEZbuYWL&paM$ zKAy)z@J=Ak+If(Ap@U77W3LpoQ7dXMAJyZM_Or~+`?Iq6-Xil$Y8_f5BXu7S#(n6FMGz859}|77~Dyj?owznb}*?*n^H${TiljbOJQs-2oP zIG`RRcl|CC0fx@>h?k2w@S~!;B7Ln0N4S2?2%?Xwb%8((;FExUJOA_FWjlp=aGFYc zTP%RfWfQ;Grbe(Ic~7R0M-o2|c3R`Gc{_q6V3zK8!lVw(bk4%>rKUOpwPG2`Z%>5$ z8PV^N9)bo!m_?X=n?P@(rjc+G;zXX}K`v*8P0EEGL)`bXx$gnWN^IJl-)#vo;-{zh zzg5?*wm-y$wBLNNf@YJe5OI4`q9doK zJmt2v@UGjL`5mp0c@OT)lvXH)@Zc97tAy8Z;b=U$Ih>+d$>$Xxk@Qwg{9P){QyN|A zNE1{D-w-Y75Pq6)B0G7IcU#y>yq~-)-Kv80De)DVQ=h+#EVW8?zK(_(8Qf*K8bTxn zdv4$G<-j{bKmrM8E5v!_LrDmYr{~XO!?NLrW6Zv6_b6)G z=HR|TKw@{;EtXnBPriOrH8brNxTRat1JT;AiDmIQQ2D9q{=2-G%cEGDKh-YD1G% zw0TRpDO3umlcgsnz02pxyY5s~$jeS9A9c%ff&;sq$I;fBjEMuS_9Hn<4N#gt!odB2 zF(eDvZ{=P5jQ^F4b|I>TAM?_&XHY?cLwgJBa69O#zL6)s$0d~TnfP^H=-M+~Wy`H4(V_Nc9B zctcflL#d?Y1n0aI%B%WAoL+E``%03tDy zhpIpgz-md2>-Zm;oWuf&1b~c388t^>x;w3;8hWLzwS}!&5o5~V4Q%j=*_>G zUH%`>jl)-jJMuTpVK`^Kr@b4YYCJJMudwxfnA71QeEW+?x*&d7l| zwa-%c(V9iyezy2(y8(!uCw25R0qY(&{On{z2$G=e)6srv=(YuN_|#68+W z&6t&zB_coQ7$O)3V;Mv{u29t`Mf{PZlbL5eooFsdM{iNTV$XJ#qG;bLi3mDZq(VHL z8{@2~c+ob|jN5ZTW6u!;fz~6GvMDkH75bY%hNnF|oN4QMLKfBPPB+>Z`+R_`@w>z= z8%o>3Zs;aEcb{vTUoG^a#~eKa>KJ@?N*A!7@C88gO?@i#c<((TawRy!t0a2Nq$MJq z&H;nFRo+n>EvK2Giv5CA=g8tDCL1@d*K~{^=y#Ax-(69y_sr}#enTVg* z-z?7r-12Y2j%E^CcY0+++d6mrXE~2F_BE8hkVIW%uT&{Ao1;Xt@*qvi*yQ~N9z`wI zJxE6#vJkTk{T3+|+N(cLR&6D0C#1r_8t>4Ik(mBj&DRsg(66Ixoq?4wCCx-A9w=aJ zWjBze0H(g6OdY~LTv0dRiU$+Qv})JT*#tlTO-H#*dJcK1EG?DD_57aWHG zwm1^pUMGlLmYq;393sC5tNqepC@eGqO^__LUOoqj-NDmz zefwN#pCc&TlubSNHUz?!iuX5e6qR9AEcgBZJ41k0iNp%CtliIfe!ZmY?%Yp+`hL*& zcyQ{-==Gt|E=Gj)uZ1c+vUKK@B7$w zTGW}-g;(3YU&%5)yKVl)&SAt>_Ra;K=uKi<=gOL2{R79_x4oOm0B->0VU;yslSDel zmZ`my+Sf-=JU;f_GMp|a`EEmAfhVLXs_RR(2i-3L8rmIH+X6gaH7@c4cwTUw$m>@v z4s6NondHQ)m$}+Y3@2&v$k?`QyLS2N*SLslGcW0;Om_&BscMxCx?k3!)a0$GKq41#$Zs^r;G9o#vYm9X^jjLjo=KlB)&Ez3XMr%J)-^cPBW&3U~{ zrFCXgc>mqJ3al*3UAa%L;u?P#)G`DWSC;TZxo#1fvng2)uL%vkH>v()skLoSS&I$F zk(jykdFa}6xZD8Twr7QVCT(>$zJUDCT+u&q61DmW-cC+!2Yt|hZXH>eO#RV*{3bEjlsI zb~|mCTzkZwyxX4^r3?gyNOET6=22ZlD3|NPuLG<6PI;cs>lGxavToBJeQ;){v7w6Z zlH)Ed%E)sO%!Pqw`wd!9HR1Hs{5 za^wzEY`W{o?1;7(ue(4L(&#E zM?0RP@z6qcN7p6Gj@DL=g@}G^9JV|y+&Zi8cn1H|VE;$YiLwA3|LtGA6eum2IAh#- z+i18r?Q!MkaO;xgt!wgUnL-{M5gMmQX{YwuUdAV8!@na+ivV9L8BV6l?rWDyHr` za>~9q^02&&9o zKfH*^ktJ*^E4vK*jvXU3qYl%)0{%gG`QL+b2NE3Z)2F@R$oiFgNK)~uT3468cUsi? zsOW2o-TLlU*VL}j!BZNG9|Ozl<#L$L!M#O^N-EE-mgfyg#Q`c;p6%waeW?_#9^#R!T_I-FUeNRR(Tp!xhQXc0tmq`$C&Ka;DUfrj?e;!@8y1xsLDo$rFq1>>V$A6;oB~ zZiY)U)G8Z6vPIdos!iIN826Eh``_d==!Cx+ZGeC@kRwzpJYqInv3w*Mqd)}(DBPEz z^76{*Y!qp^8`jAo=M|VqepjjwbYk{_KeM8MVXOE7L9b5BR{2i}nkbIJzo?I(34iKlrsk;Z-+@41CMRiC!HI@Ljg8i{ zpUY^|UT>no6>_kJ0eld?yh8|+2~GlB01;K~B&RlB#RKE@;0orj7fylWf9wi_3z&}V zmV`!?(iHAa_<>`&E6qqo``z2_I#!@Y!_72j|A#S&4<2+5l6JNI{E97WH`zwNN;q2? z>s$2Q?*$WG5Iv|bHSIeb0?6bGX-p%x`#@5exH=dhU<%Pa6I^?pE`9(zLM<<(;pMLA z$DbwP9p@ov`<4ZQuotnx5>M}v)cSmw&e0{(Nxvq?f@uYmUalvA~jLnFLLvyM;8SC-7yg-5FFfU*BDu0HFk~t;u*{n z<=@h)=B#tN(fRpB?pyIOtssK%D7JXGBA%6#0>XpKcRS|HSs^tI)^jZa%IH{2-zb_OW$#fV{?Cjw)Po@GW;)- z9nc%Gzpxm*q)hm=UAos_a@6=JBZm#5-zbcK?cEJ;CBy-W08?ZbD#~W2%w&2d4{Jr= ztK!xYReuZGvq*8iSsA==3*v{4RX-j_91YdZGij8wp-!v`Y(+i}aEhX>RFFRa^-_fu zYurYsZcHzrJdnGl{^LzgQCLjWPRK;;tM%>o5Yq^#jIDkac8acP|5)G8qNtVJDf*6J z-hAO^IV|y?sAa;2%4~R#>Us=)LK>a}!-vMIRO&3+Gc=_FP9@uvykkxNQ<~=FlVj8d z!PIQD1wIPEV~L+sVUIWEtdpd);u`s(C1AecNxLQRpMdr4Ny!+E+_niR8%0$1uY+Po z@RHBn+to{=d&#UZK_c$Fovydl`mk_AQuJ@}7wc9cO>cLof6TO!u~ZTVT+hT_;e*R2sE{=W>q-C3-OX7$LiaoH60#m(%#gAs14M;f9pXO?b5t*mpUa?`1 zsMwabji2b-#Pa%3eL}9YjyE0`5hhwXxWD#QDpm8@Xi5wy4Y9XdnkoK~HA6fIRR#ws zG6@v_{EaJ6WU~5R1A%}q1;Jf@C3BLnqB@E$VSmuFRJ)XrP#z4a8dz}_IDv52bmX$ynZWL_Pd!FjHJ$QD(+8Zu_mP z-?bT42U}od)vb_qf+Z!IgibkVuDN<}F!#f0|(v7^QJvzMFvV z18L(}2WQWE3MWrA>@vjv&Qbi=(O?PcUb#QF8Cj_Te=}lXVQogIFEw)or!6~bZn6=& zV(_PXu^vR33lsJE?)L@#Mvka&u99$Z?6ESP<4wD@OKo;5RFuxN{0;7t$1B`vNAbEy z92p&{+FCMn&p9Y~f1M9j8QuCz)!E`gn_$)@tH&dDTxGpLOD?L< z{Y^dS9+q78qY8-H@=rhfn#bi-Fkr>p#lsOlx$GS;oN+pgwQ)OJp9Xl*3ch&y7&b7? z8qvKRlTRF;QTT=Z`j0(T{~QAH0MUGggs>LVEAFcd5#J<hJo zQ9?QbkByQGEo zakMz01$Fe~p#G9pbSzw6me`nYY^_1)54e7&;P4wF93s>fu^zcF!}j7n7Y?LcaQ$~) zOLOpUy9EZM%(L~0avFhhFP(KFE7Q!eI_aVgHDR-DrocIob@ZW~(g?9Hi$gpQ&-=uI z)&1U*@GtdTg?frc;s+Pg0|G2GSDG105ct(FU}BH)8-^|1W%;+rl(;t0W;N;v!~R3SDY=*e?DOU zafyukaUAxBqCbBj5!+`pWo9aPKT4d5eZ&2MYmEeLdoheq3*ZeKP)fSddL9 zsj5^T5Mj*`xq$;20RJ9in_L`f0b;>ulc1E!fs-<{8msH+xs<^)%o*20UR@(e+uOS{ zOTkgD2WFqXsH;|tIg8j?^9vjZtu$GF6hbg<9uQIivr>j;oXXCww3+&VagIfFQjUU& zO226ND*9S=o6}7wk4XNp7bTPLR_^{JkR`9Y!=g#`rE$5)1ZBcCp|FjGg5%{>J z^3T)ppZw|9@7NAMhi=Q?hjmI22sxh4i!i%wg}j^FzP34_j_*m;6p&k>bOcZx$UEZhYNd=PihXBXWT zJ6qk3at5UohNizAtPq0C%*?6a3DS4EJHXsF_6?mmK1(HM68BDVvId#7NhNC&kLB;y z#R9y%=}khAEp8yROw5S6bbINtTa27e+n0pHXw$%LmDqKqzyH%$=%~IMsX4~!ucCRt zI4w5vzt7tIyKs?13*oSgr!@HcRs3qXsyqc74>YIB#?7nR@_6x)L39dtaqy3->-~j| zsFm1}F^~nrZ?nEHRTr0GoQ1j_B|x19Vjbhu9x90>=GPVr%RZ=Vqe40iR{Z6DqVUF4 zHvYMHSTVJ<2G&T(a9eze*E;H6SOB?q^GNZuXP+8$vVv=nbVN1Qxz8% zS8{sF|L3;hs9-e1t9*ua!st`yy!l7&QS?+2KW^;QjHP!XhC#ina@i-i?Y!rO_;#wk zUlG24X8P?NBkFbA$JCee@BZh%Uy(FKxGj=~_zSs7sR`_!2nvX;1=lms(xS@>X=t%S z`t?im0C4uQN~}5Y4lyOtPaoQqvDiQw%r3k?edkYb$y?&?mMAO)0;<u9+)i@ZFO&VJwa~gH6 zZBu*m)x+gBV^KgrK%><(y-u`yadWeq;`Vt$;lX6Sl-2j|%&u;3C0{Bu7o9OM?p-#z z(GLFpDYWwN(7sq!Q&EX4ZgJk9xSCO4PoCUS({h(RJULNfV`HP2o((4TC?6m>);Yht z2Ui%1uFn^+e{adQBue>19H}2SNIdej$4rYv3<4k{LtFRiiAb`23K72*A6w+ad=e#wmA#q^SnK7Kb)p*Xgpb~pDz6G}XZ>MUNFO8sAxmMISZ3+u6xKg4c6pWCuTn0^~mAdI}rR37l%_ z`${i09W6FG@2ekd^aPcaUo9;!+y1&3AXS%@b^dv~_BgfH;WfR~WL=fKpX=v)czCFw zB61PKD=3mq0lJE4yl#h1g~sg5e}igfQQ@5AkjKa)o$xemn^ai&@VQdy5v?W~P63Rx zjODSq5GXSLXbMT_)W?DXvwj}OA}N!ZZho*N>3Y}$>*1c}xAm^2urfEDcEiZUZwJ#3 zBFS&%l+ZJ%SvwDdGc?4$B{LwH@iR05c)eGWByVUJ%reD%DgHYvqyu3078g)h*N0_{ zV{P*}-IeX~TOB$6=QiIc4uUc5jJs&Ifuf=?ZF#hNvRin2>#vn(?Nwo~Rg*TkT-65- z(cG^q|38eqRaBc{xTcL3EAB4Ey|}x3(c-0eg9mrl;_mM54lS+;F2TLHyZy|}p1uBq zJ$vRbE9?7ClJ~LudGAXjNka(>@1QGzJ}Oxfj=#xeUEX%pf_Mckq#Aelnr4Nq^s`2? zQ$=_gRc^t0lo%IlO|$&aP)B}|hmKRWPc(b&R(PpHj^H=G<>$ob+cqx&+`aMr2PdVp zTGX!@cW#2K4ZSN7=hi?WV?NzSxkbnpoD-*UMyY3YjL-q5)xa`om=-tB6zC7ickVW( z1X!S8-Y`W4lg1twe=+vg*y56uIRi$5auIgEqz@O|6uY*qA?K5&`kOzn=taU_xvG`g zwaTieo;*I1+Pn6?*O`+?FY&Tu^0A_C?j3I>nd%#x-#xc8H6)vFD^A+d=JcD+&n+eSn0>>q40>}nEUR9-MUm2z@_*Qy zrV;50&jKlF9@*#6;g$UvHB(Wp-*w=*&@X#w@)37JLDT#)OHgqNXlDFnQ@p~tOT+LR zV~Eh%rSM~?3pT+pM)bc9!2fyH>g3=k_`D_74t#xn=Ez?@Mchf#l1~4J{9x3FI6=CR zZI&I2ksT{nO$YKwsm^aP<9bevZ$y#!a#h9X8m`Pn_e~${#V>6c>91WmV$o@5SmtRlrhsBCv94;cI_6{jovSjQ)y%nQ#xI zi?eGfo6loUQmBk{lg=z>XHN3UZBCPKzYOeAD6zeQanHf}%?FmY1W?<})7;czZF?soL zzNP~lrO!%}#*wq)gPLw{3Xq$_M=%aNY=IQ~tRaav)ypdGs~V-QPXF`goa?r_1viCO zSfNhmF!t!@6w=SlGiKQ^kA=49$4}2ynj?(O+%dp;`2LC}t^e;kLl2A#d5_+`#5JYJ z#&+q-@> z3S;TR6?pmLhw@apS0zoNJer`>)B=)1j{44Vq&MK1A8tN@Gb&5%!3yOG#F#Fg(n zwk=hu&IJJcQj(spR%0%fcPxsI9^64vh^&M4nJvF}B;kk}$J>T+najZS2w2m}C*E9jZWSyebp}M`k-GhXh zFVmN!b8|CkGQ+gy^XsW+ewzS}Pk8OMzlkEH+p}cLII}-bZ4*rAi_mtpEauX{eRP~c z!54c399LO)2I$U)UKqNOdj# zRgTlnORXo6jx3Re~87Nfb}7YX$X~HKPhO_W!D_9a1nHW)g)> z-@JFahs)U#hQn+Q2qaqRMI7wP=sXYB1(UCTvxjL-lsfKl(pY@WWh$#erK*b(0K+(Q zFlU}Onzrlm%FMhFE&j}Ts$u@+YcQR^PONZR9w`#=@V!klWj?3ubCFE^aY}uB(pdIy zfEnut^sq&wvj&X)A}k25PFMWFXG}aHl?GJHrG3<(7q>LOEc-sw$if@PN@+Yi`^e3= z{dBB5q46##>tm{dnxvxgCr?xC&{({Y83*mVLd~)Dq5X^^K<0S{=2k4wl#p5 zRi!cK7Ce}8WwY6;_6Vc`6E{&3jtn+cjVxDKDCdlh?mm1cA|aB`u2w!AIyTB)xaBIw z8{JJ3$kDB+oS~DkuMd}c`OjedUlog+`X~YI*HKxV=47zq(vgE;=bNmP zyBt(;)e~7QNGzkJX<^bA105Yew9kXmC)ThqZ8LZ_aKjIp7c|ckGeUsG+_z2 zS)H?YJxIsvPs~+8^~x&e(sAta%I-Q%q}jiIu)wkXG<<1c2CYa9Fex`b znd=yQ+Zw9$b+;rD zY4m=BkGB(*@WoV+bvE<#V)bl`qff_PjQ)HAmAG`M$|%QDbvWlt?vr?&#qHJv93Y}k zl9AgiX=ePZJF3OXtIa|mFx4!3(#Gkf5m3KtM<&*O}{~mxF#+ zQlf4OaqO?u@B)fNe+=f`yZ{*~zoq|A{qX-z*dJOywf8F=U*hcqd~9^|@>RBou3y32 zajx*UtTwX$_4LJzr2pm01~kT2l?mt*LlkaD;wEs|Bj=J`K;V~ArH30vu9){sS?s~3 zs!MF+oq`85?j9)(uDKcm)A{9GTFi%`Xm+QuoT~7>#4jtnMTY0A$g1f{F%1%IN>lAY zz6cDO>|(e!#wzfo|7rJ z%|CeC8~fV=*Y2l(R)$vkH-?1{hNWDxgoQzr6VK1)2GwGn?#~Xfmdjn;%rioMLfsyA z%QRP;X?~Q;gOE>|ik&;zrY41aF0dHzy7Qlsa zW@}LtTf2cBq*L99BhPh4V9Nh5XM2-Le~I&GabZi%WAK7x*i_Gtm5>HVw#sDnq;;l2 zi)oDS#pXxBj9zlxY8dC~>1kHZ%H)!M>gMcH@<9lh_B<+f-kaAc27>tMs&yAlkClx@ z+@*#P5 zh#5tBpA}<~er9A8%J@o$yl_U>QGU!F|D9qe!af`I1&^^80R2s(P7FHSq{;}hjAkQ8 zKtN!o(U#>f%J?nS`7H%F<8ffe1&@{!@n6M+|Nm%3Q5Ndh$!%V+oZC6{*S%mOj~c8AoIZ3bJ^uiBgqz=g>9%+0oCO5f6Yj|Pvh3PU zqYtwt4P_)^W0b}jc~kY~;}W!VFDo1cAu~)hZ3ZdZ(ppkxjZMNe-TOav&$QL$+wu2+ zuLUTr%i1$~Gt#=H_oT#1(H(TP_lL=gModii0dw;-PDaV(1SE3i@fQa+248s3YiB%< z@V+)H5*OP$GbtVwd;maI>VP%?tmbbhMdu>~YN+ z1VMcFm(YJbcbM(3j;hGdW|75}Q#Dr7wR)^yUpIyK?_cs8&@TZ!{e_X?an1kjwwLO@ zzZlfsr0B4~Tpp)j@!4Tqa0yov8oUPH-SRCMy8b(6BXv75r+9yIeiewfysGVW|FGI$ zeaYC)e=%{A7}nahk(JfZ>&%x_#QdmvTo&JzVEYpj+Ouw=BK63A7zE)RTd5@={_pVf ze@IFfKjDt({uv3yYKv~6A#w2WS*5sUXJ;>GU3486fJ!t(&!4xuO!w_XltBB~UZ~jELNq zQj1tYuSM^r;sM;(lrs$!QqEY;F@2DF&88f8Hc@d4&V01JVX%9q>J~`yQ>~S^zAx;bp(E;v;Ce zn*|*R4F$w0q>@%o7@nb56Kvt`1bDqWv}@mq>TA^0cQ@;6>|MsNjB~Fy(~Kw3M-)-3 z<1oZir4@<=N`cy^|7CTapRR9Q``$Yn`$G|kLCCI2Ht$kFZhgQRodb^`)SFlnp3W3L zjK{Uosu3>_@5=sTeV}AA>Tfl?BhCmSPud`^VB|lI^3r)qg!9SIg^2`Oe|G;Of?$7D zT3H>5Pgm!IPBh7blDZh(jdsNY#8-Y>KY?l}0RdS$26PA5bzK1=+3#(orbu$V^wOD> z-newq9ZH|A*(VDdjPqZnPuLVf$ba%^X^6XVdD~#)i;6NJt{`L8Q22h@xNJXay8THj z@%mv6DFk;)Q~kz;%i7Tt!jay9TvzUYm_wb9M9s(KZZ!JiJom?+6o_F0GozI{$U&$Y z*??NL`y)|bRLYlt3_5>&wpmNk_5*T&kyD-|z(dg45U_IomQsqSz{V*A2sHvVQ%>H_!6OqqjH4=7?`1^0hXzz;7 zM(Ts5q{>ZP;8BvR@_0I6O=s=(J7nuN>i!U{d&#FyDd}tJLn-uoIQ&nq9UN$}c|(4* z|9i4iRbUOb9c(J)w(fxl0!IpNq=SWsUvkZ>#d2<(#d39HZjSsv`V;^lR4)QnVHxh) zvxN%4-8Pzhybp_j*7x`Kcj4Xkm*`3%oDoaX>}R1dZ(%5YuZqs`6gJ~CqG86yhp*Mx z{Co_gja_U}v@>#O;`iV=HFP|cq)^|C;nK}I#$8TgRu<(R3E4(3rne#0ERq)Id4uCt z0b=m{3IX2lFchkUPb`WrBuC(o(WYo?VYz5MbM0LZOp%5@4lQLX=|z2$@V25j#aMB$ zO5R`4Q({Hv;)Fg~PX$ye|0ne1Kz|Vh-3rS5K~#&GZtZy4{){~g^nNvi9S#Tx)>KweqF)k(@5<<+KWkF+4^#qK4jt{Yx7NVW^5LFhvm*0hJScY@<~xvq?-O;>qc zTAxmzk96X+XIJ2oh3CH5kbUA1={f?JM~oEsDT@b3j=8pM!s#zJnk^=4YxXC>&&z|y zX64V4r9ERmB+)KsOCwdcP++mK_8U+-;{FTFyEY~tuxGj%EKOs#qZB|EKTDNR{EZoY z5(Sy4ZBIk`QS1(3%f#tMNU@@CPebX^yAb$Z`bBhJ`uy|Sw$E393OY@v)%#Tq8M=Bcq@5&#FeBok*Tbp4Sc4%(Be&mqXUey@*2f1!1o_)esy!tuWW7O3o$=! zugTc7U4J0R{*DG+F(R2jaO8`lx7rgvds&ZMDPd!()blx< zjmk5!aKt@+NxG@zHiepBVY2Y&B-~Mj9ahevfw=5mVcrfs$~X589tA#KQq5zS`_Vtwv*l`%5_JdG zpRa+B;>Fxmaz2hb!0ES8{w#;$lbX}JjjFVlm$vyg&F}N_8q(?xYz?^}93x8(H_Aw% zL*;?}l3>^yS44r#c4W7mum4@b{GVsZT@>R2)rSY8Ijro};FO_5`$sxf?A7#oA&yHC zVNO@!!^y67nBi8_!)W*J`GklG*5yqvBvq?N{8~*_>l3_iqRjrI1U=AQc5hnsd7AJp z26z%1#=$83dd>G9=}M|qqc)_bv&MuzOD+94*#JDH3*$4f*L}#%QCLPfzi684C>_+! zu5V*Ff3}H1gm>585YvS-UhZuCP$x!5xL4 zRA{J&hV?`H{`8EhIr{nG+LhC>zyx^jGHAiWokyc3owK;y97-1k-Na*h72DU7!dH#D z8SGP0C1=QnfIeu39<{ntZUB7%sQRvDT9{_gs)QYALZ9n;5==s;tSc)1*!F#Tr14j! z_*ZTeYhHHGhNMC#FMt~9K**=n0pgs9x*Qq;nsdM}boVaqK{r2H7q{I}*`?q-p$*p0 zpYwdsjdiuQ1I@qc_rl##8^-S<$2eI%tE=R%3#8=s8upy;KEfv+$m_^Ae2^fltu(a& zkub6OYgqx*lS)(((Bp#nprU_5lB<0()9k8+x`qKQZQe;tWq;@W`{SyfpvLlijQTm_ zt4lpURh70bLM)q2@yOJ_FJBUe?P`xOvYY`lqksSQK$ru*d4*y46UNWJsKvBkdiGAF ztBS{rGk21VT7H|9X-#*KI7{S8d_MfAQ3bV#v>eY@%@@{z;ty}(UEG6#y_jRu>>k5zQGPj%JD%%>|?@(*AQX@sgRp4M~{?dAq{)y^N?lz4@X?I_CLF5l>^z zIKr-+u%oi|rDAZx_k6{RG|YK#hp$Nzqt4wga{r7xCd{xHdK0NPgD#tJ6p@A{|NA2H zq@|Xi8#>VXwY2`VxkE!ML>CrS+553s){XvK%hL0?4;{j>WVYkaRY>*#kV!~kQWaLnEE?v>WLG7mlqtv7`v{#Q`1iO_Ko@1#R3Et>*(7KF>x;AT z`GYEQMKM3a97|W}L7zB4w*Ap{4V`kc$Zh;Q>_9I9CeqjJYI?Qkp(iv?_^c~wU->E{ z*i9*4Ict&fO+Y5hf5+}b?)a38l40SEazw6N&TDDXOlue2IuDF;A ziz(NV?;iulHus=v<&kMvLGV;u@<&?o6d2y18xFd?eYQOzKgiqm%8NXNwunD5XY9f? zzo%y*ivEnxQL?%@k>?h_*$D-~ByWcHcCP)IXPBh-$sQ3p%)uvrcviN*QyG;+(`HdG z=dYAoNyMnQ$geAF@5IDe>XH@NX*@8DUQM8ic;S9U#hUXoJ-HZ+uDGvl0#6V{$<+*2 zZjq@DMe*X4rsZSD$JFG|QB|Ei5#w(mMgt)=Cv`E!AzE`3TNRF)>jTP+cj+~M1j^sc zePQcFOJpgE6-KV9;pz39ywAzIU&z;`y^-mC@qQZXjXiod>xDdD4YNK!Q-x{m7hQH; znEN^N{&CX#Jp)VUKqz)`;jBL5G&7(l#P*F}AnGb(pjFbSXEK?vb+}EqA^-%YgC8=p z6)}%SjY#R~V*GQT2)9ojF31tt@?r*pho`3bGJ87nEA@{US|SF6-PpjZ66u%%5i)qT z5dqQbh!t^8w;M~2b82!e(x0{v0+Hfer{OJ6Z8`!r9TrLbm{Tn?9r-%SswA=MLiu@* zfx7I>Y z5;e*H!)XzrWN+lnI$3=*GPYJ#-3<=Mp<`&09Ja{j8N*HpdVn-sFDAJ4tK`)rskC{u z6sXjrGb<0|MVI*~?P2q5kFR~tIrUk~j2K_1G2d|s1TBkNhzc2U7y8uDQCiV)ooI%7 zy|2n9zZ!^xLCwUTEl!mp$a~-}R8aEYl~tWzXy&>?Yu8xUvJauxK)j}tHFqM+2X+dK zq5S;<&dG*c-FH8`z?X>^u0}VN@*0v^Y@ETKGu@PHW!(6f*MFqK_HG-q%0DiJXt#u1&a>kVBqhJpbhD9tFKQ3$gr*a| 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