diff --git a/.codeboarding/Datadog API Client.md b/.codeboarding/Datadog API Client.md new file mode 100644 index 000000000..e54129a78 --- /dev/null +++ b/.codeboarding/Datadog API Client.md @@ -0,0 +1,325 @@ +```mermaid +graph LR + Datadog_API_Client["Datadog API Client"] + DogStatsd_Core["DogStatsd Core"] + ThreadStats_Aggregation_Reporting["ThreadStats Aggregation & Reporting"] + Dogshell_CLI_Utilities["Dogshell CLI Utilities"] + Datadog_Agent["Datadog Agent"] + Datadog_API_Endpoint["Datadog API Endpoint"] + Metric_Aggregators["Metric Aggregators"] + HTTP_Client_Resolver["HTTP Client Resolver"] + Utility_Modules["Utility Modules"] + API_Resources["API Resources"] + Dogshell_Commands["Dogshell Commands"] + DogStatsd_Core -- "sends data to" --> Datadog_Agent + DogStatsd_Core -- "uses" --> Metric_Aggregators + DogStatsd_Core -- "uses" --> Utility_Modules + ThreadStats_Aggregation_Reporting -- "sends data to" --> Datadog_API_Endpoint + ThreadStats_Aggregation_Reporting -- "uses" --> Metric_Aggregators + ThreadStats_Aggregation_Reporting -- "uses" --> Datadog_API_Client + Datadog_API_Client -- "sends requests to" --> Datadog_API_Endpoint + Datadog_API_Client -- "uses" --> HTTP_Client_Resolver + Datadog_API_Client -- "uses" --> Utility_Modules + Dogshell_CLI_Utilities -- "uses" --> Utility_Modules + Dogshell_CLI_Utilities -- "configures" --> Datadog_API_Client + API_Resources -- "uses" --> Datadog_API_Client + Dogshell_Commands -- "uses" --> Datadog_API_Client + Dogshell_Commands -- "uses" --> DogStatsd_Core + Dogshell_Commands -- "uses" --> Dogshell_CLI_Utilities +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This architecture describes the core components of the Datadog Python client library, focusing on how it interacts with the Datadog API and the DogStatsd Agent. The main flow involves sending metrics, events, and service checks to Datadog. This is achieved either directly via HTTP requests to the Datadog API or by sending DogStatsd-formatted data to a local Datadog Agent. The system also includes utilities for command-line interactions and robust error handling. + +### Datadog API Client +The foundational component for all interactions with the Datadog HTTP API, managing API key authentication, request submission, error handling (including exceptions from `datadog.api.exceptions`), retry logic, and providing interfaces for various Datadog API endpoints. It utilizes different HTTP client implementations. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.api.api_client.APIClient` (21:290) +- `datadogpy.datadog.api.api_client.APIClient:submit` (48:236) +- `datadogpy.datadog.api.api_client.APIClient:_get_http_client` (38:45) +- `datadogpy.datadog.api.api_client.APIClient:_should_submit` (239:280) +- `datadogpy.datadog.api.http_client.RequestClient` (81:126) +- `datadogpy.datadog.api.http_client.RequestClient:request` (91:126) +- `datadogpy.datadog.api.http_client.URLFetchClient` (129:183) +- `datadogpy.datadog.api.http_client.URLFetchClient:request` (135:170) +- `datadogpy.datadog.api.http_client.URLFetchClient:raise_on_status` (173:183) +- `datadogpy.datadog.api.http_client.Urllib3Client` (186:235) +- `datadogpy.datadog.api.http_client.Urllib3Client:request` (195:225) +- `datadogpy.datadog.api.http_client.Urllib3Client:raise_on_status` (228:235) +- `datadog.api.exceptions` (full file reference) +- `datadog.util.compat` (full file reference) +- `datadog.util.format` (full file reference) + + +### DogStatsd Core +This component provides the core functionality for sending DogStatsd-formatted metrics (gauges, counts, histograms, distributions, timings), events, and service checks. It manages metric aggregation, buffering, and the underlying socket communication (UDP/UDS) with the Datadog Agent. It also includes features like origin detection and client telemetry. + + +**Related Classes/Methods**: + +- `datadog.dogstatsd.base.DogStatsd` (146:1704) +- `datadog.dogstatsd.base.DogStatsd.__init__` (155:503) +- `datadog.dogstatsd.base.DogStatsd.gauge` (923:941) +- `datadog.dogstatsd.base.DogStatsd.count` (967:984) +- `datadog.dogstatsd.base.DogStatsd.increment` (1009:1027) +- `datadog.dogstatsd.base.DogStatsd.decrement` (1029:1048) +- `datadog.dogstatsd.base.DogStatsd.histogram` (1050:1067) +- `datadog.dogstatsd.base.DogStatsd.distribution` (1069:1086) +- `datadog.dogstatsd.base.DogStatsd.timing` (1088:1104) +- `datadog.dogstatsd.base.DogStatsd.event` (1431:1505) +- `datadog.dogstatsd.base.DogStatsd.service_check` (1507:1550) +- `datadog.dogstatsd.base.DogStatsd.flush_buffered_metrics` (901:909) +- `datadog.dogstatsd.base.DogStatsd.flush_aggregated_metrics` (911:921) +- `datadog.dogstatsd.base.DogStatsd._report` (1215:1255) +- `datadog.dogstatsd.base.DogStatsd._send_to_server` (1313:1326) +- `datadog.dogstatsd.base.DogStatsd._send_to_buffer` (1408:1416) +- `datadog.dogstatsd.base.DogStatsd._xmit_packet` (1343:1406) +- `datadog.dogstatsd.base.DogStatsd.get_socket` (735:769) +- `datadog.dogstatsd.base.DogStatsd._get_udp_socket` (831:856) +- `datadog.dogstatsd.base.DogStatsd._get_uds_socket` (797:828) +- `datadog.dogstatsd.base.DogStatsd._start_flush_thread` (605:639) +- `datadog.dogstatsd.base.DogStatsd._start_sender_thread` (1590:1606) + + +### ThreadStats Aggregation & Reporting +This component provides a high-performance, in-application mechanism for collecting and aggregating metrics and events. It aggregates data in memory and then uses a dedicated reporter to flush the collected data to the Datadog API, either synchronously, in a dedicated thread, or in a gevent greenlet. + + +**Related Classes/Methods**: + +- `datadog.threadstats.base.ThreadStats` (41:511) +- `datadog.threadstats.base.ThreadStats.start` (85:164) +- `datadog.threadstats.base.ThreadStats.stop` (166:172) +- `datadog.threadstats.base.ThreadStats.event` (174:212) +- `datadog.threadstats.base.ThreadStats.gauge` (214:228) +- `datadog.threadstats.base.ThreadStats.increment` (243:255) +- `datadog.threadstats.base.ThreadStats.decrement` (257:268) +- `datadog.threadstats.base.ThreadStats.histogram` (270:282) +- `datadog.threadstats.base.ThreadStats.distribution` (284:296) +- `datadog.threadstats.base.ThreadStats.timing` (298:307) +- `datadog.threadstats.base.ThreadStats.flush` (367:418) +- `datadog.threadstats.base.ThreadStats._get_aggregate_metrics_and_dists` (420:458) +- `datadog.threadstats.base.ThreadStats._get_aggregate_events` (460:463) +- `datadog.threadstats.base.ThreadStats._start_flush_thread` (465:487) +- `datadog.threadstats.base.ThreadStats._start_flush_greenlet` (489:511) +- `datadog.threadstats.reporters.HttpReporter` (17:29) + + +### Dogshell CLI Utilities +This component provides common utility functions for the `dogshell` command-line interface. Its responsibilities include loading configuration from files or user input, handling API and application keys, and reporting errors and warnings to the console. + + +**Related Classes/Methods**: + +- `datadog.dogshell.common.DogshellConfig` (45:122) +- `datadog.dogshell.common.DogshellConfig.load` (46:122) +- `datadog.dogshell.common.print_err` (13:18) +- `datadog.dogshell.common.report_errors` (21:30) +- `datadog.dogshell.common.report_warnings` (33:42) +- `datadog.util.config` (full file reference) + + +### Datadog Agent +Represents the Datadog Agent, which receives DogStatsd metrics, events, and service checks from the `DogStatsd Core` component. + + +**Related Classes/Methods**: _None_ + +### Datadog API Endpoint +Represents the Datadog HTTP API, which receives data from the `Datadog API Client` and `ThreadStats Aggregation & Reporting` components. + + +**Related Classes/Methods**: _None_ + +### Metric Aggregators +Internal components responsible for aggregating different types of metrics (e.g., counters, gauges, histograms) before they are sent. + + +**Related Classes/Methods**: + +- `datadog.dogstatsd.aggregator.Aggregator` (17:118) +- `datadog.dogstatsd.metric_types.MetricType` (1:7) +- `datadog.dogstatsd.max_sample_metric.MaxSampleMetric` (7:52) +- `datadog.dogstatsd.max_sample_metric_context.MaxSampleMetricContext` (full file reference) +- `datadog.dogstatsd.metrics.Metrics` (full file reference) +- `datadog.threadstats.metrics.MetricsAggregator` (171:203) +- `datadog.threadstats.events.EventsAggregator` (11:27) +- `datadog.threadstats.metrics.Counter` (67:83) +- `datadog.threadstats.metrics.Gauge` (49:64) +- `datadog.threadstats.metrics.Histogram` (104:159) +- `datadog.threadstats.metrics.Timing` (162:168) +- `datadog.threadstats.metrics.Distribution` (86:101) +- `datadog.threadstats.metrics.Set` (31:46) + + +### HTTP Client Resolver +Component responsible for resolving and providing the appropriate underlying HTTP client for making requests. It abstracts the specific HTTP client implementation. + + +**Related Classes/Methods**: + +- `datadog.api.http_client.resolve_http_client` (238:256) +- `datadog.api.http_client.HTTPClient` (59:78) + + +### Utility Modules +A collection of common utility modules used across various Datadog client components for tasks like compatibility checks, formatting, and tag normalization. + + +**Related Classes/Methods**: + +- `datadog.util.compat` (full file reference) +- `datadog.util.format` (full file reference) +- `datadog.util.hostname` (full file reference) +- `datadog.util.config` (full file reference) +- `datadog.util.cli` (full file reference) + + +### API Resources +Modules that provide high-level interfaces for interacting with specific Datadog API resources (e.g., AWS integrations, dashboards, metrics, monitors). These modules typically use the Datadog API Client to perform their operations. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.api.resources.CreateableAPIResource:create` (17:50) +- `datadogpy.datadog.api.resources.SendableAPIResource:send` (59:92) +- `datadogpy.datadog.api.resources.UpdatableAPIResource:update` (101:119) +- `datadogpy.datadog.api.resources.CustomUpdatableAPIResource:update` (128:155) +- `datadogpy.datadog.api.resources.DeletableAPIResource:delete` (164:176) +- `datadogpy.datadog.api.resources.GetableAPIResource:get` (185:200) +- `datadogpy.datadog.api.resources.ListableAPIResource:get_all` (209:220) +- `datadogpy.datadog.api.resources.ListableAPISubResource:get_items` (229:247) +- `datadogpy.datadog.api.resources.AddableAPISubResource:add_items` (256:279) +- `datadogpy.datadog.api.resources.UpdatableAPISubResource:update_items` (288:311) +- `datadogpy.datadog.api.resources.DeletableAPISubResource:delete_items` (320:343) +- `datadogpy.datadog.api.resources.SearchableAPIResource:_search` (352:363) +- `datadogpy.datadog.api.resources.ActionAPIResource:_trigger_class_action` (372:407) +- `datadogpy.datadog.api.resources.ActionAPIResource:_trigger_action` (410:436) +- `datadogpy.datadog.api.resources.UpdatableAPISyntheticsSubResource:update_synthetics_items` (445:468) +- `datadogpy.datadog.api.resources.UpdatableAPISyntheticsResource:update_synthetics` (477:495) +- `datadogpy.datadog.api.resources.ActionAPISyntheticsResource:_trigger_synthetics_class_action` (504:539) +- `datadogpy.datadog.api.metrics.Metric:list` (22:39) +- `datadogpy.datadog.api.metrics.Metric:send` (54:111) +- `datadogpy.datadog.api.metrics.Metric:query` (114:147) +- `datadogpy.datadog.api.distributions.Distribution:send` (15:45) +- `datadogpy.datadog.api.tags.Tag:create` (21:36) +- `datadogpy.datadog.api.tags.Tag:update` (39:54) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:list` (16:22) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:delete` (25:34) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:create` (37:67) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:update` (70:93) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:get_all` (34:43) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:get` (46:55) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:create` (58:67) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:update` (70:81) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:delete` (84:93) +- `datadogpy.datadog.api.monitors.Monitor` (14:157) +- `datadogpy.datadog.api.monitors.Monitor:get` (29:45) +- `datadogpy.datadog.api.monitors.Monitor:get_all` (48:72) +- `datadogpy.datadog.api.monitors.Monitor:mute` (75:88) +- `datadogpy.datadog.api.monitors.Monitor:unmute` (91:103) +- `datadogpy.datadog.api.monitors.Monitor:mute_all` (106:112) +- `datadogpy.datadog.api.monitors.Monitor:unmute_all` (115:121) +- `datadogpy.datadog.api.monitors.Monitor:search` (124:130) +- `datadogpy.datadog.api.monitors.Monitor:search_groups` (133:139) +- `datadogpy.datadog.api.monitors.Monitor:can_delete` (142:148) +- `datadogpy.datadog.api.monitors.Monitor:validate` (151:157) +- `datadogpy.datadog.api.users.User:invite` (30:50) +- `datadogpy.datadog.api.screenboards.Screenboard:share` (29:38) +- `datadogpy.datadog.api.screenboards.Screenboard:revoke` (41:50) +- `datadogpy.datadog.api.events.Event:create` (18:69) +- `datadogpy.datadog.api.events.Event:query` (72:95) +- `datadogpy.datadog.api.infrastructure.Infrastructure:search` (15:28) +- `datadogpy.datadog.api.synthetics.Synthetics:get_test` (31:45) +- `datadogpy.datadog.api.synthetics.Synthetics:get_all_tests` (48:61) +- `datadogpy.datadog.api.synthetics.Synthetics:get_devices` (64:75) +- `datadogpy.datadog.api.synthetics.Synthetics:get_locations` (78:89) +- `datadogpy.datadog.api.synthetics.Synthetics:get_results` (92:106) +- `datadogpy.datadog.api.synthetics.Synthetics:get_result` (109:126) +- `datadogpy.datadog.api.synthetics.Synthetics:create_test` (129:163) +- `datadogpy.datadog.api.synthetics.Synthetics:edit_test` (166:178) +- `datadogpy.datadog.api.synthetics.Synthetics:start_or_pause_test` (181:196) +- `datadogpy.datadog.api.synthetics.Synthetics:delete_test` (199:214) +- `datadogpy.datadog.api.roles.Roles:update` (32:41) +- `datadogpy.datadog.api.roles.Roles:assign_permission` (44:56) +- `datadogpy.datadog.api.roles.Roles:unassign_permission` (59:71) +- `datadogpy.datadog.api.service_checks.ServiceCheck:check` (15:45) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:list` (24:30) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:create` (33:45) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:delete` (48:57) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:update_host_filters` (60:72) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:update` (75:91) +- `datadogpy.datadog.api.logs.Logs:list` (16:22) +- `datadogpy.datadog.api.downtimes.Downtime:cancel_downtime_by_scope` (29:38) +- `datadogpy.datadog.api.hosts.Host:mute` (15:35) +- `datadogpy.datadog.api.hosts.Host:unmute` (38:48) +- `datadogpy.datadog.api.hosts.Hosts:search` (59:82) +- `datadogpy.datadog.api.hosts.Hosts:totals` (85:94) +- `datadogpy.datadog.api.hosts.Hosts:get_all` (97:135) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:list_log_services` (16:23) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:add_log_lambda_arn` (26:37) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:save_services` (40:50) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:delete_config` (53:64) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:check_lambda` (67:85) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:check_services` (88:101) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:list` (104:111) +- `datadogpy.datadog.api.metadata.Metadata:get` (16:27) +- `datadogpy.datadog.api.metadata.Metadata:update` (30:64) +- `datadogpy.datadog.api.graphs.Graph:create` (16:34) +- `datadogpy.datadog.api.graphs.Graph:status` (37:52) +- `datadogpy.datadog.api.graphs.Embed:enable` (63:72) +- `datadogpy.datadog.api.graphs.Embed:revoke` (75:84) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:create` (30:38) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:get` (41:50) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:get_all` (53:89) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:update` (92:101) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:delete` (104:113) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:bulk_delete` (116:133) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:delete_many` (136:151) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:can_delete` (154:174) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:history` (177:204) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:search` (207:213) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:list` (30:36) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:create` (39:97) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:update` (100:213) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:delete` (216:225) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:list_namespace_rules` (228:235) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:generate_new_external_id` (238:248) +- `datadogpy.datadog.api.security_monitoring_signals.SecurityMonitoringSignal:get` (30:39) +- `datadogpy.datadog.api.security_monitoring_signals.SecurityMonitoringSignal:get_all` (42:58) +- `datadogpy.datadog.api.security_monitoring_signals.SecurityMonitoringSignal:change_triage_state` (61:84) + + +### Dogshell Commands +Modules that implement specific commands for the `dogshell` command-line interface, interacting with the Datadog API and DogStatsd client. + + +**Related Classes/Methods**: + +- `datadog.dogshell.comment` (full file reference) +- `datadog.dogshell.dashboard` (full file reference) +- `datadog.dogshell.dashboard_list` (full file reference) +- `datadog.dogshell.downtime` (full file reference) +- `datadog.dogshell.event` (full file reference) +- `datadog.dogshell.host` (full file reference) +- `datadog.dogshell.hosts` (full file reference) +- `datadog.dogshell.metric` (full file reference) +- `datadog.dogshell.monitor` (full file reference) +- `datadog.dogshell.screenboard` (full file reference) +- `datadog.dogshell.search` (full file reference) +- `datadog.dogshell.security_monitoring` (full file reference) +- `datadog.dogshell.service_check` (full file reference) +- `datadog.dogshell.service_level_objective` (full file reference) +- `datadog.dogshell.tag` (full file reference) +- `datadog.dogshell.timeboard` (full file reference) +- `datadog.dogshell.wrap` (full file reference) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/DogStatsd Client.md b/.codeboarding/DogStatsd Client.md new file mode 100644 index 000000000..9b6b18850 --- /dev/null +++ b/.codeboarding/DogStatsd Client.md @@ -0,0 +1,120 @@ +```mermaid +graph LR + DogStatsd_Client_Core["DogStatsd Client Core"] + Metric_Aggregation_Sampling["Metric Aggregation & Sampling"] + Metric_Context_Decorators["Metric Context Decorators"] + System_Information_Network_Resolution["System Information & Network Resolution"] + Data_Formatting_Validation_Utilities["Data Formatting & Validation Utilities"] + Container_ID_Detection["Container ID Detection"] + DogStatsd_Client_Core -- "initializes and uses" --> Metric_Aggregation_Sampling + DogStatsd_Client_Core -- "uses" --> Metric_Context_Decorators + DogStatsd_Client_Core -- "depends on" --> System_Information_Network_Resolution + DogStatsd_Client_Core -- "uses" --> Data_Formatting_Validation_Utilities + DogStatsd_Client_Core -- "uses" --> Container_ID_Detection + Metric_Aggregation_Sampling -- "uses" --> Data_Formatting_Validation_Utilities + Metric_Context_Decorators -- "interacts with" --> DogStatsd_Client_Core + System_Information_Network_Resolution -- "uses" --> Data_Formatting_Validation_Utilities +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +The DogStatsd Client subsystem provides core functionality for sending metrics, events, and service checks to the Datadog Agent via UDP or UDS. This includes initialization, socket management, buffering, flushing, and metric aggregation. It is composed of several interconnected components that handle different aspects of data collection, formatting, and transmission, ensuring efficient and accurate reporting to Datadog. + +### DogStatsd Client Core +The primary interface for sending metrics, events, and service checks to the DogStatsd agent. It handles connection management (UDP/UDS sockets), buffering, flushing, and background sending of data. It also manages client-level configurations like constant tags and telemetry. + + +**Related Classes/Methods**: + +- `datadog.initialize` (full file reference) +- `datadog.dogstatsd.base.DogStatsd` (146:1704) +- `datadog.dogstatsd.base.DogStatsd:__init__` (155:503) +- `datadog.dogstatsd.base.DogStatsd:gauge` (923:941) +- `datadog.dogstatsd.base.DogStatsd:count` (967:984) +- `datadog.dogstatsd.base.DogStatsd:histogram` (1050:1067) +- `datadog.dogstatsd.base.DogStatsd:event` (1431:1505) +- `datadog.dogstatsd.base.DogStatsd:service_check` (1507:1550) +- `datadog.dogstatsd.base.DogStatsd:_send_to_server` (1313:1326) +- `datadog.dogstatsd.base.DogStatsd:_xmit_packet` (1343:1406) + + +### Metric Aggregation & Sampling +This component is responsible for collecting and aggregating various metric types (Count, Gauge, Set, Histogram, Distribution, Timing) before they are transmitted. It also manages sampling logic for certain metric types to control data volume. + + +**Related Classes/Methods**: + +- `datadog.dogstatsd.aggregator.Aggregator` (17:118) +- `datadog.dogstatsd.aggregator.Aggregator:__init__` (18:35) +- `datadog.dogstatsd.aggregator.Aggregator:flush_aggregated_metrics` (37:46) +- `datadog.dogstatsd.aggregator.Aggregator:count` (63:66) +- `datadog.dogstatsd.aggregator.Aggregator:gauge` (68:71) +- `datadog.dogstatsd.aggregator.Aggregator:histogram` (93:96) +- `datadog.dogstatsd.metrics.CountMetric:__init__` (19:22) +- `datadog.dogstatsd.metrics.GaugeMetric:__init__` (29:32) +- `datadog.dogstatsd.metrics.SetMetric:__init__` (39:45) +- `datadog.dogstatsd.metrics.SetMetric:get_data` (50:54) +- `datadog.dogstatsd.max_sample_metric.MaxSampleMetric:maybe_keep_sample_work_unsafe` (28:39) +- `datadog.dogstatsd.max_sample_metric.MaxSampleMetric:flush` (44:52) +- `datadog.dogstatsd.max_sample_metric.HistogramMetric:__init__` (56:57) +- `datadog.dogstatsd.max_sample_metric.DistributionMetric:__init__` (61:64) +- `datadog.dogstatsd.max_sample_metric.TimingMetric:__init__` (68:69) +- `datadog.dogstatsd.max_sample_metric_context.MaxSampleMetricContexts:sample` (21:36) + + +### Metric Context Decorators +Provides Python context managers and decorators (@timed, @distributed) to simplify the process of timing code execution and sending distribution metrics. + + +**Related Classes/Methods**: + +- `datadog.dogstatsd.context.TimedContextManagerDecorator` (21:93) +- `datadog.dogstatsd.context.DistributedContextManagerDecorator` (96:111) + + +### System Information & Network Resolution +This component handles the retrieval of system-specific information like hostnames and resolves network routes, particularly for determining the DogStatsd agent's address in dynamic environments (e.g., containers). + + +**Related Classes/Methods**: + +- `datadog.util.hostname.get_hostname` (45:125) +- `datadog.util.hostname.is_valid_hostname` (25:42) +- `datadog.util.hostname.GCE.get_hostname` (185:190) +- `datadog.util.hostname.EC2.get_instance_id` (301:305) +- `datadog.dogstatsd.route.get_default_route` (18:40) +- `datadog.dogstatsd.route.UnresolvableDefaultRoute` (12:15) + + +### Data Formatting & Validation Utilities +A set of utility functions responsible for formatting metric tags, validating data cardinality, and escaping special characters in event and service check messages to ensure they conform to the DogStatsd protocol. It also includes Python version compatibility checks. + + +**Related Classes/Methods**: + +- `datadog.util.format.normalize_tags` (40:43) +- `datadog.util.format.validate_cardinality` (46:53) +- `datadog.util.format._normalize_tags_with_cache` (36:37) +- `datadog.util.compat.is_p3k` (103:107) +- `datadog.util.compat._is_py_version_higher_than` (96:100) +- `datadog.dogstatsd.base.DogStatsd._escape_event_content` (1424:1425) +- `datadog.dogstatsd.base.DogStatsd._escape_service_check_message` (1428:1429) + + +### Container ID Detection +This component is dedicated to automatically detecting and providing the container ID of the running application, which is crucial for Datadog's origin detection feature to enrich metrics with container-specific metadata. + + +**Related Classes/Methods**: + +- `datadog.dogstatsd.container.Cgroup` (17:111) +- `datadog.dogstatsd.container.Cgroup._is_host_cgroup_namespace` (50:59) +- `datadog.dogstatsd.container.Cgroup._read_cgroup_path` (61:81) +- `datadog.dogstatsd.container.Cgroup._get_cgroup_from_inode` (83:111) +- `datadog.dogstatsd.container.UnresolvableContainerID` (11:14) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/DogStatsd Context Managers.md b/.codeboarding/DogStatsd Context Managers.md new file mode 100644 index 000000000..8c76b73e8 --- /dev/null +++ b/.codeboarding/DogStatsd Context Managers.md @@ -0,0 +1,74 @@ +```mermaid +graph LR + MetricContextManager["MetricContextManager"] + DistributionContextManager["DistributionContextManager"] + DogStatsdClient["DogStatsdClient"] + AsyncWrapper["AsyncWrapper"] + DogStatsdClient -- "instantiates" --> MetricContextManager + DogStatsdClient -- "instantiates" --> DistributionContextManager + DistributionContextManager -- "inherits from" --> MetricContextManager + MetricContextManager -- "uses for async functions" --> AsyncWrapper + MetricContextManager -- "reports metrics to" --> DogStatsdClient + AsyncWrapper -- "delegates metric sending to" --> MetricContextManager +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This subsystem provides context managers and decorators for automatically timing code blocks and managing distributed tracing contexts for DogStatsd metrics. It allows developers to easily instrument their code to send timing and distribution metrics to DogStatsd, supporting both synchronous and asynchronous operations. The core functionality revolves around managing the lifecycle of a metric timer and delegating the actual metric submission to the DogStatsd client. + +### MetricContextManager +This component provides context management and decorator functionality for timing code execution. It is responsible for starting and stopping timers and delegating the actual metric submission to the DogStatsd client. It supports both regular and asynchronous functions. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator` (21:93) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:__call__` (43:67) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:__enter__` (69:73) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:__exit__` (75:77) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:start` (89:90) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:stop` (92:93) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator._send` (79:87) + + +### DistributionContextManager +This component extends the MetricContextManager to specifically handle distribution metrics. It inherits the timing and context management capabilities but directs the metric reporting to the distribution function of the DogStatsd client. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogstatsd.context.DistributedContextManagerDecorator` (96:111) +- `datadogpy.datadog.dogstatsd.context.DistributedContextManagerDecorator:__init__` (102:111) + + +### DogStatsdClient +This is the core client component responsible for initializing the DogStatsd connection, managing buffering and aggregation of metrics, and providing methods for sending various types of metrics (gauge, count, histogram, timing, distribution), events, and service checks. It also handles socket communication and telemetry. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogstatsd.base.DogStatsd` (146:1704) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:timed` (1106:1138) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:distributed` (1140:1166) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:timing` (1088:1104) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:distribution` (1069:1086) +- `datadogpy.datadog.dogstatsd.base.DogStatsd._report` (1215:1255) +- `datadogpy.datadog.dogstatsd.base.DogStatsd._send_to_server` (1313:1326) +- `datadogpy.datadog.dogstatsd.base.DogStatsd._send_to_buffer` (1408:1416) +- `datadogpy.datadog.dogstatsd.base.DogStatsd.flush_buffered_metrics` (901:909) +- `datadogpy.datadog.dogstatsd.base.DogStatsd.flush_aggregated_metrics` (911:921) + + +### AsyncWrapper +This component provides a specific wrapper for asynchronous (coroutine) functions when they are decorated for timing. It ensures that the timing logic correctly awaits the wrapped coroutine and then sends the metric. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogstatsd.context_async._get_wrapped_co` (45:48) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Dogshell API Clients.md b/.codeboarding/Dogshell API Clients.md new file mode 100644 index 000000000..4e525f5ad --- /dev/null +++ b/.codeboarding/Dogshell API Clients.md @@ -0,0 +1,189 @@ +```mermaid +graph LR + CLI_Entry_Point["CLI Entry Point"] + Dogshell_API_Clients["Dogshell API Clients"] + Common_CLI_Utilities["Common CLI Utilities"] + Output_Formatting_Utilities["Output Formatting Utilities"] + Core_Datadog_API_Interface["Core Datadog API Interface"] + CLI_Process_Wrapper["CLI Process Wrapper"] + CLI_Entry_Point -- "initializes" --> Core_Datadog_API_Interface + CLI_Entry_Point -- "configures" --> Dogshell_API_Clients + CLI_Entry_Point -- "utilizes" --> Common_CLI_Utilities + CLI_Entry_Point -- "utilizes" --> CLI_Process_Wrapper + Dogshell_API_Clients -- "invokes" --> Core_Datadog_API_Interface + Dogshell_API_Clients -- "reports status via" --> Common_CLI_Utilities + Dogshell_API_Clients -- "formats output via" --> Output_Formatting_Utilities + Common_CLI_Utilities -- "prints errors via" --> Common_CLI_Utilities + CLI_Process_Wrapper -- "handles process execution for" --> CLI_Entry_Point +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This graph illustrates the architecture of the Datadog command-line interface (dogshell) subsystem. The main flow begins with the `CLI Entry Point`, which parses command-line arguments, loads configuration, and initializes the core Datadog API. It then dispatches commands to various `Dogshell API Clients`, each responsible for interacting with a specific Datadog API resource (e.g., monitors, events, dashboards). These clients, in turn, invoke the `Core Datadog API Interface` to perform the actual API calls. Throughout this process, `Common CLI Utilities` are used for error reporting and warnings, and `Output Formatting Utilities` ensure that API responses are presented in a human-readable format. The `CLI Process Wrapper` handles external process execution, supporting functionalities like event creation from process output. + +### CLI Entry Point +This component serves as the main entry point for the Datadog command-line interface. It initializes the Datadog API, loads configuration, and sets up the command parsers for various Datadog services. + + +**Related Classes/Methods**: + +- `datadog.dogshell:main` (full file reference) + + +### Dogshell API Clients +Provides various client classes for interacting with specific Datadog API resources via the command-line interface, encapsulating logic for CRUD operations on different Datadog services. + + +**Related Classes/Methods**: + +- `datadog.dogshell.downtime.DowntimeClient:_schedule_downtime` (67:76) +- `datadog.dogshell.downtime.DowntimeClient:_update_downtime` (79:90) +- `datadog.dogshell.downtime.DowntimeClient:_cancel_downtime` (93:98) +- `datadog.dogshell.downtime.DowntimeClient:_show_downtime` (101:110) +- `datadog.dogshell.downtime.DowntimeClient:_show_all_downtime` (113:122) +- `datadog.dogshell.downtime.DowntimeClient:_cancel_downtime_by_scope` (125:132) +- `datadog.dogshell.host.HostClient:_mute` (40:49) +- `datadog.dogshell.host.HostClient:_unmute` (52:61) +- `datadog.dogshell.tag.TagClient:_add` (48:62) +- `datadog.dogshell.tag.TagClient:_replace` (65:79) +- `datadog.dogshell.tag.TagClient:_show` (82:112) +- `datadog.dogshell.tag.TagClient:_detach` (115:120) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_create` (178:233) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_file_create` (236:246) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_update` (249:302) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_file_update` (305:316) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_show` (319:332) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_show_all` (335:352) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete` (355:365) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete_many` (368:378) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete_timeframe` (381:394) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_can_delete` (397:408) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_history` (411:422) +- `datadog.dogshell.comment.CommentClient:_post` (43:69) +- `datadog.dogshell.comment.CommentClient:_update` (72:98) +- `datadog.dogshell.comment.CommentClient:_reply` (101:128) +- `datadog.dogshell.comment.CommentClient:_show` (131:152) +- `datadog.dogshell.service_check.ServiceCheckClient:_check` (35:55) +- `datadog.dogshell.monitor.MonitorClient` (16:474) +- `datadog.dogshell.monitor.MonitorClient:_post` (171:208) +- `datadog.dogshell.monitor.MonitorClient:_file_post` (211:238) +- `datadog.dogshell.monitor.MonitorClient:_update` (241:291) +- `datadog.dogshell.monitor.MonitorClient:_file_update` (294:323) +- `datadog.dogshell.monitor.MonitorClient:_show` (326:339) +- `datadog.dogshell.monitor.MonitorClient:_show_all` (342:374) +- `datadog.dogshell.monitor.MonitorClient:_delete` (377:383) +- `datadog.dogshell.monitor.MonitorClient:_mute_all` (390:399) +- `datadog.dogshell.monitor.MonitorClient:_unmute_all` (402:407) +- `datadog.dogshell.monitor.MonitorClient:_mute` (410:419) +- `datadog.dogshell.monitor.MonitorClient:_unmute` (422:430) +- `datadog.dogshell.monitor.MonitorClient:_can_delete` (433:440) +- `datadog.dogshell.monitor.MonitorClient:_validate` (443:474) +- `datadog.dogshell.dashboard_list.DashboardListClient:_post` (141:153) +- `datadog.dogshell.dashboard_list.DashboardListClient:_update` (156:169) +- `datadog.dogshell.dashboard_list.DashboardListClient:_show` (172:184) +- `datadog.dogshell.dashboard_list.DashboardListClient:_show_all` (187:198) +- `datadog.dogshell.dashboard_list.DashboardListClient:_delete` (201:213) +- `datadog.dogshell.dashboard_list.DashboardListClient:_show_dashboards` (216:228) +- `datadog.dogshell.dashboard_list.DashboardListClient:_show_dashboards_v2` (231:243) +- `datadog.dogshell.dashboard_list.DashboardListClient:_add_dashboards` (246:259) +- `datadog.dogshell.dashboard_list.DashboardListClient:_add_dashboards_v2` (262:275) +- `datadog.dogshell.dashboard_list.DashboardListClient:_update_dashboards` (278:291) +- `datadog.dogshell.dashboard_list.DashboardListClient:_update_dashboards_v2` (294:307) +- `datadog.dogshell.dashboard_list.DashboardListClient:_delete_dashboards` (310:323) +- `datadog.dogshell.dashboard_list.DashboardListClient:_delete_dashboards_v2` (326:339) +- `datadog.dogshell.dashboard.DashboardClient:_post` (91:117) +- `datadog.dogshell.dashboard.DashboardClient:_update` (120:146) +- `datadog.dogshell.dashboard.DashboardClient:_show` (149:159) +- `datadog.dogshell.dashboard.DashboardClient:_delete` (162:167) +- `datadog.dogshell.hosts.HostsClient:_list` (69:88) +- `datadog.dogshell.hosts.HostsClient:_totals` (91:100) +- `datadog.dogshell.timeboard.TimeboardClient:_pull` (118:119) +- `datadog.dogshell.timeboard.TimeboardClient:_pull_all` (122:156) +- `datadog.dogshell.timeboard.TimeboardClient:_new_file` (159:178) +- `datadog.dogshell.timeboard.TimeboardClient:_write_dash_to_file` (181:204) +- `datadog.dogshell.timeboard.TimeboardClient:_push` (207:253) +- `datadog.dogshell.timeboard.TimeboardClient:_post` (256:271) +- `datadog.dogshell.timeboard.TimeboardClient:_update` (274:294) +- `datadog.dogshell.timeboard.TimeboardClient:_show` (297:310) +- `datadog.dogshell.timeboard.TimeboardClient:_show_all` (313:330) +- `datadog.dogshell.timeboard.TimeboardClient:_delete` (333:338) +- `datadog.dogshell.metric.MetricClient:_post` (43:72) +- `datadog.dogshell.screenboard.ScreenboardClient:_pull` (116:117) +- `datadog.dogshell.screenboard.ScreenboardClient:_push` (121:152) +- `datadog.dogshell.screenboard.ScreenboardClient:_write_screen_to_file` (155:175) +- `datadog.dogshell.screenboard.ScreenboardClient:_post` (178:199) +- `datadog.dogshell.screenboard.ScreenboardClient:_update` (202:224) +- `datadog.dogshell.screenboard.ScreenboardClient:_show` (233:246) +- `datadog.dogshell.screenboard.ScreenboardClient:_delete` (249:255) +- `datadog.dogshell.screenboard.ScreenboardClient:_share` (258:266) +- `datadog.dogshell.screenboard.ScreenboardClient:_revoke` (269:277) +- `datadog.dogshell.screenboard.ScreenboardClient:_new_file` (280:298) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_show_rule` (157:161) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_show_all_rules` (164:175) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_create_rule` (178:192) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_update_rule` (195:209) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_delete_rule` (212:219) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_list_signals` (222:244) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_get_signal` (247:254) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_change_triage_state` (257:264) +- `datadog.dogshell.search.SearchClient:_query` (25:43) +- `datadog.dogshell.event.EventClient:_post` (117:157) +- `datadog.dogshell.event.EventClient:_show` (160:171) +- `datadog.dogshell.event.EventClient:_stream` (174:201) +- `datadog.dogshell.event:print_event` (32:33) +- `datadog.dogshell.event:prettyprint_event_details` (36:37) +- `datadog.dogshell.event:print_event_details` (40:41) + + +### Common CLI Utilities +This component provides shared utility functions for the command-line interface, including reporting warnings and errors to the user, printing error messages, and handling the loading of dogshell configuration. + + +**Related Classes/Methods**: + +- `datadog.dogshell.common.report_warnings` (33:42) +- `datadog.dogshell.common.report_errors` (21:30) +- `datadog.dogshell.common.print_err` (13:18) +- `datadog.dogshell.common.DogshellConfig` (45:122) + + +### Output Formatting Utilities +This component is responsible for formatting the output of API responses, primarily converting data structures into human-readable JSON format for display in the command-line interface. + + +**Related Classes/Methods**: + +- `datadog.util.format.pretty_json` (17:18) + + +### Core Datadog API Interface +This component represents the underlying Python client for interacting directly with the Datadog API. It provides methods for various Datadog services like Downtime, Security Monitoring Rules, and Signals. + + +**Related Classes/Methods**: + +- `datadog.api` (full file reference) +- `datadog.api.security_monitoring_rules.SecurityMonitoringRule` (18:93) +- `datadog.api.security_monitoring_signals.SecurityMonitoringSignal` (16:84) +- `datadog.initialize` (full file reference) + + +### CLI Process Wrapper +This component provides utilities for wrapping external process execution within the CLI, including handling timeouts, reading output, and building event bodies from process information. + + +**Related Classes/Methods**: + +- `datadog.dogshell.wrap.poll_proc` (90:102) +- `datadog.dogshell.wrap.execute` (105:166) +- `datadog.dogshell.wrap.build_event_body` (192:232) +- `datadog.dogshell.wrap.parse_options` (252:404) +- `datadog.dogshell.wrap.Timeout` (47:48) +- `datadog.dogshell.wrap.OutputReader` (51:87) +- `datadog.dogshell.wrap.trim_text` (169:189) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Dogshell CLI Core.md b/.codeboarding/Dogshell CLI Core.md new file mode 100644 index 000000000..64ffbe308 --- /dev/null +++ b/.codeboarding/Dogshell CLI Core.md @@ -0,0 +1,218 @@ +```mermaid +graph LR + Dogshell_CLI_Core["Dogshell CLI Core"] + CLI_Argument_Parsing_Utilities["CLI Argument Parsing & Utilities"] + Core_Initialization["Core Initialization"] + Downtime_CLI["Downtime CLI"] + Host_CLI["Host CLI"] + Tag_CLI["Tag CLI"] + Service_Level_Objective_CLI["Service Level Objective CLI"] + Monitor_CLI["Monitor CLI"] + Event_CLI["Event CLI"] + Security_Monitoring_CLI["Security Monitoring CLI"] + Dogshell_CLI_Core -- "initializes" --> Core_Initialization + Downtime_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Downtime_CLI -- "formats output using" --> CLI_Argument_Parsing_Utilities + Host_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Host_CLI -- "formats output using" --> CLI_Argument_Parsing_Utilities + Tag_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Service_Level_Objective_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Service_Level_Objective_CLI -- "formats output using" --> CLI_Argument_Parsing_Utilities + Monitor_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Monitor_CLI -- "formats output using" --> CLI_Argument_Parsing_Utilities + Event_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Event_CLI -- "uses" --> CLI_Argument_Parsing_Utilities + Security_Monitoring_CLI -- "reports errors/warnings using" --> Dogshell_CLI_Core + Security_Monitoring_CLI -- "formats output using" --> CLI_Argument_Parsing_Utilities + Dogshell_CLI_Core -- "uses" --> CLI_Argument_Parsing_Utilities +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +The Dogshell CLI Core acts as the central orchestrator for the `dogshell` command-line application. It is responsible for parsing command-line arguments, loading configuration settings, handling error and warning reporting, and then dispatching the parsed commands to the appropriate specialized CLI clients (e.g., Downtime CLI, Host CLI, Tag CLI, Service Level Objective CLI, Monitor CLI, Event CLI, Security Monitoring CLI). It initializes the core Datadog client and leverages utility functions for argument parsing and output formatting. + +### Dogshell CLI Core +The main entry point for the `dogshell` command-line application, handling argument parsing, configuration loading, error reporting, and dispatching commands to specific CLI clients. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogshell.wrap:main` (407:514) +- `datadogpy.datadog.dogshell.wrap:parse_options` (252:404) +- `datadogpy.datadog.dogshell.wrap:execute` (105:166) +- `datadogpy.datadog.dogshell.wrap:poll_proc` (90:102) +- `datadogpy.datadog.dogshell.wrap:build_event_body` (192:232) +- `datadogpy.datadog.dogshell.common:print_err` (13:18) +- `datadogpy.datadog.dogshell.common:report_errors` (21:30) +- `datadogpy.datadog.dogshell.common:report_warnings` (33:42) +- `datadogpy.datadog.dogshell.common.DogshellConfig:load` (46:122) + + +### CLI Argument Parsing & Utilities +This component contains general utility functions primarily used for parsing command-line arguments and handling date/time conversions across various `dogshell` commands. It also includes compatibility utilities for different Python versions and JSON formatting. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.util.cli:comma_list` (12:16) +- `datadogpy.datadog.util.cli:comma_set` (19:20) +- `datadogpy.datadog.util.cli:comma_list_or_empty` (23:27) +- `datadogpy.datadog.util.cli:list_of_ints_and_strs` (48:55) +- `datadogpy.datadog.util.cli:set_of_ints` (58:59) +- `datadogpy.datadog.util.cli:parse_date_as_epoch_timestamp` (74:75) +- `datadogpy.datadog.util.cli:parse_date` (83:152) +- `datadogpy.datadog.util.compat.is_p3k` (103:107) +- `datadogpy.datadog.util.format.pretty_json` (17:18) + + +### Core Initialization +This component is responsible for the initial setup and configuration of the Datadog client. It handles tasks such as resolving hostnames, managing DogStatsd socket connections, and enabling/disabling aggregation. It also interacts with system-level configurations to determine hostname and operating system details. + + +**Related Classes/Methods**: + +- `datadog:initialize` (full file reference) +- `datadog.dogstatsd.base.DogStatsd.resolve_host` (721:733) +- `datadog.dogstatsd.base.DogStatsd.close_socket` (1179:1196) +- `datadog.dogstatsd.base.DogStatsd.disable_aggregation` (695:707) +- `datadog.dogstatsd.base.DogStatsd.enable_aggregation` (709:718) +- `datadog.util.config.get_config` (106:130) +- `datadog.util.config.get_os` (24:37) +- `datadog.util.hostname.get_hostname` (45:125) +- `datadog.util.hostname.is_valid_hostname` (25:42) +- `datadog.util.hostname.GCE.get_hostname` (185:190) +- `datadog.util.hostname.EC2.get_instance_id` (301:305) +- `datadog.util.hostname.GCE._get_metadata` (152:182) +- `datadog.util.hostname.EC2.get_metadata` (243:298) +- `datadog.util.hostname.get_hostname._get_hostname_unix` (full file reference) + + +### Downtime CLI +This component provides command-line functionalities for managing Datadog downtimes. It allows users to schedule, update, cancel, and view existing downtimes. + + +**Related Classes/Methods**: + +- `datadog.dogshell.downtime.DowntimeClient` (15:132) +- `datadog.dogshell.downtime.DowntimeClient:_schedule_downtime` (67:76) +- `datadog.dogshell.downtime.DowntimeClient:_update_downtime` (79:90) +- `datadog.dogshell.downtime.DowntimeClient:_cancel_downtime` (93:98) +- `datadog.dogshell.downtime.DowntimeClient:_show_downtime` (101:110) +- `datadog.dogshell.downtime.DowntimeClient:_show_all_downtime` (113:122) + + +### Host CLI +This component offers command-line tools for managing hosts within Datadog. It supports operations such as muting and unmuting hosts, listing all hosts, and retrieving host totals. + + +**Related Classes/Methods**: + +- `datadog.dogshell.host.HostClient` (15:61) +- `datadog.dogshell.host.HostClient:_mute` (40:49) +- `datadog.dogshell.host.HostClient:_unmute` (52:61) +- `datadog.dogshell.hosts.HostsClient` (16:100) +- `datadog.dogshell.hosts.HostsClient:_list` (69:88) +- `datadog.dogshell.hosts.HostsClient:_totals` (91:100) + + +### Tag CLI +This component enables command-line operations for managing tags associated with Datadog resources. Users can add, replace, show, and detach tags. + + +**Related Classes/Methods**: + +- `datadog.dogshell.tag.TagClient` (12:120) +- `datadog.dogshell.tag.TagClient:_add` (48:62) +- `datadog.dogshell.tag.TagClient:_replace` (65:79) +- `datadog.dogshell.tag.TagClient:_show` (82:112) +- `datadog.dogshell.tag.TagClient:_detach` (115:120) + + +### Service Level Objective CLI +This component provides command-line tools for managing Service Level Objectives (SLOs) in Datadog. It supports creating, updating, showing, and deleting SLOs, including operations from files and managing multiple SLOs. + + +**Related Classes/Methods**: + +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient` (22:426) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_create` (178:233) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_file_create` (236:246) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_update` (249:302) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_file_update` (305:316) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_show` (319:332) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_show_all` (335:352) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete` (355:365) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete_many` (368:378) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete_timeframe` (381:394) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_can_delete` (397:408) +- `datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_history` (411:422) + + +### Monitor CLI +This component manages Datadog monitors through the command-line interface. It supports a wide range of operations including creating, updating, showing, and deleting monitors, as well as muting and unmuting them. + + +**Related Classes/Methods**: + +- `datadog.dogshell.monitor.MonitorClient` (16:474) +- `datadog.dogshell.monitor.MonitorClient:_post` (171:208) +- `datadog.dogshell.monitor.MonitorClient:_file_post` (211:238) +- `datadog.dogshell.monitor.MonitorClient:_update` (241:291) +- `datadog.dogshell.monitor.MonitorClient:_file_update` (294:323) +- `datadog.dogshell.monitor.MonitorClient:_show` (326:339) +- `datadog.dogshell.monitor.MonitorClient:_show_all` (342:374) +- `datadog.dogshell.monitor.MonitorClient._escape` (386:387) +- `datadog.dogshell.monitor.MonitorClient:_delete` (377:383) +- `datadog.dogshell.monitor.MonitorClient:_mute_all` (390:399) +- `datadog.dogshell.monitor.MonitorClient:_unmute_all` (402:407) +- `datadog.dogshell.monitor.MonitorClient:_mute` (410:419) +- `datadog.dogshell.monitor.MonitorClient:_unmute` (422:430) + + +### Event CLI +This component provides command-line tools for managing events in Datadog. It supports posting new events, showing details of existing events, and streaming events. + + +**Related Classes/Methods**: + +- `datadog.dogshell.event.EventClient` (67:201) +- `datadog.dogshell.event:print_event` (32:33) +- `datadog.dogshell.event:prettyprint_event` (19:29) +- `datadog.dogshell.event:prettyprint_event_details` (36:37) +- `datadog.dogshell.event:print_event_details` (40:41) +- `datadog.dogshell.event.EventClient:_post` (117:157) +- `datadog.dogshell.event.EventClient:_show` (160:171) +- `datadog.dogshell.event.EventClient:_stream` (174:201) +- `datadog.dogshell.event.parse_time` (44:64) + + +### Security Monitoring CLI +This component provides command-line tools for managing security monitoring rules and signals in Datadog. It allows users to show, create, update, and delete rules, as well as list, get, and change the triage state of signals. + + +**Related Classes/Methods**: + +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient` (48:264) +- `datadog.dogshell.security_monitoring:api_cmd` (20:45) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_show_rule` (157:161) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_show_all_rules` (164:175) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_create_rule` (178:192) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_update_rule` (195:209) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_delete_rule` (212:219) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_list_signals` (222:244) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_get_signal` (247:254) +- `datadog.dogshell.security_monitoring.SecurityMonitoringClient:_change_triage_state` (257:264) +- `datadog.api.security_monitoring_rules.SecurityMonitoringRule.get` (46:55) +- `datadog.api.security_monitoring_rules.SecurityMonitoringRule.get_all` (34:43) +- `datadog.api.security_monitoring_rules.SecurityMonitoringRule.create` (58:67) +- `datadog.api.security_monitoring_rules.SecurityMonitoringRule.update` (70:81) +- `datadog.api.security_monitoring_rules.SecurityMonitoringRule.delete` (84:93) +- `datadog.api.security_monitoring_signals.SecurityMonitoringSignal.get_all` (42:58) +- `datadog.api.security_monitoring_signals.SecurityMonitoringSignal.get` (30:39) +- `datadog.api.security_monitoring_signals.SecurityMonitoringSignal.change_triage_state` (61:84) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/ThreadStats AWS Lambda Integration.md b/.codeboarding/ThreadStats AWS Lambda Integration.md new file mode 100644 index 000000000..a57e7e7ba --- /dev/null +++ b/.codeboarding/ThreadStats AWS Lambda Integration.md @@ -0,0 +1,93 @@ +```mermaid +graph LR + LambdaIntegration["LambdaIntegration"] + ThreadStatsCore["ThreadStatsCore"] + MetricsAggregation["MetricsAggregation"] + EventsAggregation["EventsAggregation"] + Reporting["Reporting"] + PeriodicTimer["PeriodicTimer"] + APIClientInitialization["APIClientInitialization"] + LambdaIntegration -- "initializes and uses" --> ThreadStatsCore + ThreadStatsCore -- "manages and aggregates metrics via" --> MetricsAggregation + ThreadStatsCore -- "manages and aggregates events via" --> EventsAggregation + ThreadStatsCore -- "sends data to" --> Reporting + ThreadStatsCore -- "uses for scheduled flushing" --> PeriodicTimer + LambdaIntegration -- "initiates" --> APIClientInitialization +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This subsystem provides specific integration for Datadog ThreadStats within AWS Lambda environments. Its main purpose is to enable automatic metric collection and manage the lifecycle of the ThreadStats client in a serverless context. The core flow involves a Lambda decorator that initializes a ThreadStats client, collects metrics and events during the Lambda function's execution, and then flushes these aggregated metrics and events to the Datadog API upon completion. + +### LambdaIntegration +This component provides a decorator for AWS Lambda functions to automatically initialize and flush Datadog metrics. It manages the lifecycle of metric collection within a Lambda execution context, ensuring metrics are sent to Datadog. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator` (22:77) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:__call__` (71:77) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:_enter` (35:50) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:_close` (53:69) +- `datadogpy.datadog.threadstats.aws_lambda:_get_lambda_stats` (84:90) +- `datadogpy.datadog.threadstats.aws_lambda:lambda_metric` (93:95) + + +### ThreadStatsCore +This is the core component for collecting and managing application metrics. It provides methods for various metric types (gauge, increment, histogram, distribution, timing, event) and handles the flushing mechanism, either in a separate thread, greenlet, or manually. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.base.ThreadStats` (41:511) + + +### MetricsAggregation +This component is responsible for aggregating various types of metrics (counters, gauges, histograms, distributions, timings, sets) before they are flushed. It manages the roll-up of metric data. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.metrics.MetricsAggregator` (171:203) + + +### EventsAggregation +This component handles the aggregation of events before they are sent to Datadog. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.events.EventsAggregator` (11:27) + + +### Reporting +This component is responsible for sending the aggregated metrics and events to the Datadog API. It handles the actual HTTP communication. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.reporters.HttpReporter` (17:29) + + +### PeriodicTimer +This component provides a mechanism for scheduling periodic tasks, used by ThreadStatsCore for automatic flushing in a separate thread. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.periodic_timer.PeriodicTimer` (13:36) + + +### APIClientInitialization +This component handles the asynchronous initialization of the Datadog API client, specifically to pre-establish TLS connections and reduce latency for subsequent metric submissions. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.aws_lambda._init_api_client` (98:111) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/ThreadStats Client.md b/.codeboarding/ThreadStats Client.md new file mode 100644 index 000000000..0c682ab62 --- /dev/null +++ b/.codeboarding/ThreadStats Client.md @@ -0,0 +1,126 @@ +```mermaid +graph LR + ThreadStats_Core["ThreadStats Core"] + Metric_Type_Handlers["Metric Type Handlers"] + Metric_Aggregator["Metric Aggregator"] + Event_Aggregator["Event Aggregator"] + HTTP_Reporting["HTTP Reporting"] + Lambda_Wrapper_Deprecated_["Lambda Wrapper (Deprecated)"] + Periodic_Timer["Periodic Timer"] + Lambda_Wrapper_Deprecated_ -- "initializes and manages" --> ThreadStats_Core + ThreadStats_Core -- "aggregates metrics using" --> Metric_Aggregator + ThreadStats_Core -- "aggregates events using" --> Event_Aggregator + ThreadStats_Core -- "reports data via" --> HTTP_Reporting + ThreadStats_Core -- "schedules flushes with" --> Periodic_Timer + Metric_Aggregator -- "handles various" --> Metric_Type_Handlers +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This graph illustrates the architecture of the `ThreadStats Client` subsystem. The core functionality revolves around the `ThreadStats Core` component, which acts as the central hub for collecting and managing metrics and events. It interacts with `Metric Aggregator` and `Event Aggregator` to process and store different types of data. The `Metric Aggregator` further utilizes `Metric Type Handlers` to manage specific metric types like histograms, gauges, and counters. For reporting, the `ThreadStats Core` sends aggregated data to the `HTTP Reporting` component, which handles the communication with the Datadog API. Automated flushing of metrics is managed by the `Periodic Timer` component, which is scheduled by the `ThreadStats Core`. Additionally, a `Lambda Wrapper (Deprecated)` component is present, which historically initialized and managed the `ThreadStats Core` in AWS Lambda environments, ensuring proper metric flushing at the end of function execution. + +### ThreadStats Core +The central component for collecting and managing application metrics and events. It provides an API for users to submit various metric types and events, and orchestrates their aggregation and flushing to Datadog. It can be configured to flush metrics in a separate thread, greenlet, or manually. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.base.ThreadStats` (41:511) +- `datadogpy.datadog.threadstats.base.ThreadStats:start` (85:164) +- `datadogpy.datadog.threadstats.base.ThreadStats:stop` (166:172) +- `datadogpy.datadog.threadstats.base.ThreadStats:event` (174:212) +- `datadogpy.datadog.threadstats.base.ThreadStats:gauge` (214:228) +- `datadogpy.datadog.threadstats.base.ThreadStats:set` (230:241) +- `datadogpy.datadog.threadstats.base.ThreadStats:increment` (243:255) +- `datadogpy.datadog.threadstats.base.ThreadStats:decrement` (257:268) +- `datadogpy.datadog.threadstats.base.ThreadStats:histogram` (270:282) +- `datadogpy.datadog.threadstats.base.ThreadStats:distribution` (284:296) +- `datadogpy.datadog.threadstats.base.ThreadStats:timing` (298:307) +- `datadogpy.datadog.threadstats.base.ThreadStats:timer` (310:335) +- `datadogpy.datadog.threadstats.base.ThreadStats:timed` (337:365) +- `datadogpy.datadog.threadstats.base.ThreadStats:flush` (367:418) +- `datadogpy.datadog.threadstats.base.ThreadStats:_get_aggregate_metrics_and_dists` (420:458) +- `datadogpy.datadog.threadstats.base.ThreadStats:_get_aggregate_events` (460:463) +- `datadogpy.datadog.threadstats.base.ThreadStats:_start_flush_thread` (465:487) +- `datadogpy.datadog.threadstats.base.ThreadStats:_start_flush_greenlet` (489:511) + + +### Metric Type Handlers +These classes define how individual metric types (like Histogram, Gauge, Counter, Set, Distribution, Timing) process and store their points before aggregation. They also define how these individual metrics are flushed into a format suitable for reporting. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.metrics.Histogram` (104:159) +- `datadogpy.datadog.threadstats.metrics.Histogram:add_point` (122:130) +- `datadogpy.datadog.threadstats.metrics.Histogram:flush` (132:155) +- `datadogpy.datadog.threadstats.metrics.Histogram.average` (157:159) +- `datadogpy.datadog.threadstats.metrics.Set` (31:46) +- `datadogpy.datadog.threadstats.metrics.Gauge` (49:64) +- `datadogpy.datadog.threadstats.metrics.Counter` (67:83) +- `datadogpy.datadog.threadstats.metrics.Distribution` (86:101) +- `datadogpy.datadog.threadstats.metrics.Timing` (162:168) + + +### Metric Aggregator +Responsible for collecting and rolling up various types of metrics over defined time intervals. It manages instances of individual metric handlers and orchestrates their flushing to produce aggregated metric data. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.metrics.MetricsAggregator` (171:203) +- `datadogpy.datadog.threadstats.metrics.MetricsAggregator.add_point` (181:188) +- `datadogpy.datadog.threadstats.metrics.MetricsAggregator.flush` (190:203) + + +### Event Aggregator +A simple aggregator that collects events and holds them in memory until a flush operation is triggered. It prepares the collected events for submission to the Datadog API. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.events.EventsAggregator` (11:27) +- `datadogpy.datadog.threadstats.events.EventsAggregator:add_event` (19:22) +- `datadogpy.datadog.threadstats.events.EventsAggregator:flush` (24:27) + + +### HTTP Reporting +Handles the actual transmission of aggregated metrics, distributions, and events to the Datadog API. It uses the Datadog API client to send the prepared payloads, optionally compressing them. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.reporters.HttpReporter` (17:29) +- `datadogpy.datadog.threadstats.reporters.HttpReporter.flush_metrics` (24:25) +- `datadogpy.datadog.threadstats.reporters.HttpReporter.flush_distributions` (21:22) +- `datadogpy.datadog.threadstats.reporters.HttpReporter.flush_events` (27:29) + + +### Lambda Wrapper (Deprecated) +A deprecated decorator and utility functions designed for AWS Lambda environments. It automatically initializes the ThreadStats client and ensures that metrics are flushed at the end of a Lambda function's execution, handling API key setup and asynchronous client initialization. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator` (22:77) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:_enter` (35:50) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:_close` (53:69) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:__call__` (71:77) +- `datadogpy.datadog.threadstats.aws_lambda:_get_lambda_stats` (84:90) +- `datadogpy.datadog.threadstats.aws_lambda:lambda_metric` (93:95) + + +### Periodic Timer +A utility class that runs a specified function periodically in a separate thread. It is used by the ThreadStats Core to automate the flushing process at regular intervals. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.periodic_timer.PeriodicTimer` (13:36) +- `datadogpy.datadog.threadstats.periodic_timer.PeriodicTimer.end` (25:26) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Utility - Core.md b/.codeboarding/Utility - Core.md new file mode 100644 index 000000000..9463eeca7 --- /dev/null +++ b/.codeboarding/Utility - Core.md @@ -0,0 +1,84 @@ +```mermaid +graph LR + HostnameResolver["HostnameResolver"] + ConfigurationManager["ConfigurationManager"] + PythonCompatibilityLayer["PythonCompatibilityLayer"] + DataFormatter["DataFormatter"] + HostnameResolver -- "uses" --> PythonCompatibilityLayer + HostnameResolver -- "uses" --> ConfigurationManager + ConfigurationManager -- "uses" --> PythonCompatibilityLayer + DataFormatter -- "uses" --> PythonCompatibilityLayer +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This graph illustrates the core utility components of the `datadogpy` library, focusing on how they collaborate to manage system hostnames, handle configuration files, ensure Python version compatibility, and format data for API interactions. The `HostnameResolver` identifies the system's unique identifier, relying on `ConfigurationManager` for settings and `PythonCompatibilityLayer` for cross-version compatibility. The `ConfigurationManager` is responsible for parsing agent configurations, also leveraging the `PythonCompatibilityLayer` for file I/O and parsing. Finally, the `DataFormatter` prepares various data types, such as tags and time series, for submission to the Datadog API, utilizing the `PythonCompatibilityLayer` for efficient caching mechanisms. + +### HostnameResolver +This component is responsible for determining the canonical hostname of the system. It attempts to retrieve the hostname from various sources, including the agent configuration, OS-specific methods (like 'hostname -f' on Unix), and cloud provider metadata services (Google Cloud Engine and Amazon EC2). It also includes logic for validating hostnames. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.util.hostname:get_hostname` (45:125) +- `datadogpy.datadog.util.hostname.GCE:get_hostname` (185:190) +- `datadogpy.datadog.util.hostname.EC2:get_tags` (201:240) +- `datadogpy.datadog.util.hostname.EC2:get_instance_id` (301:305) +- `datadogpy.datadog.util.hostname:is_valid_hostname` (25:42) +- `datadogpy.datadog.util.hostname.GCE._get_metadata` (152:182) +- `datadogpy.datadog.util.hostname.EC2.get_metadata` (243:298) +- `datadogpy.datadog.util.hostname.get_hostname._get_hostname_unix` (129:141) + + +### ConfigurationManager +This component handles the loading and parsing of the Datadog agent's configuration file (datadog.conf). It determines the correct configuration file path based on the operating system and provides methods to read configuration options. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.util.config:skip_leading_wsp` (40:45) +- `datadogpy.datadog.util.config:_windows_config_path` (66:71) +- `datadogpy.datadog.util.config:_unix_config_path` (74:78) +- `datadogpy.datadog.util.config:_mac_config_path` (81:86) +- `datadogpy.datadog.util.config:get_config_path` (89:103) +- `datadogpy.datadog.util.config:get_config` (106:130) +- `datadogpy.datadog.util.config:get_os` (24:37) +- `datadogpy.datadog.util.config.CfgNotFound` (16:17) +- `datadogpy.datadog.util.config.PathNotFound` (20:21) + + +### PythonCompatibilityLayer +This component provides a set of utility functions and conditional imports to ensure the `datadogpy` library functions correctly across different Python versions (specifically Python 2.x and Python 3.x). It includes helpers for version checks, string/IO handling, and iterator compatibility. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.util.compat:is_p3k` (103:107) +- `datadogpy.datadog.util.compat:is_higher_py32` (110:114) +- `datadogpy.datadog.util.compat:is_higher_py35` (117:121) +- `datadogpy.datadog.util.compat:conditional_lru_cache` (131:145) +- `datadogpy.datadog.util.compat:_is_py_version_higher_than` (96:100) +- `datadogpy.datadog.util.compat:iteritems` (48:49) +- `datadogpy.datadog.util.compat:url_lib` (39:39) +- `datadogpy.datadog.util.compat:configparser` (40:40) + + +### DataFormatter +This component provides utility functions for formatting various data types, including normalizing tags, pretty-printing JSON, validating cardinality, formatting time series points, and constructing URLs. It ensures data adheres to expected formats for interaction with the Datadog API. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.util.format:normalize_tags` (40:43) +- `datadogpy.datadog.util.format:pretty_json` (17:18) +- `datadogpy.datadog.util.format:validate_cardinality` (46:53) +- `datadogpy.datadog.util.format:construct_url` (21:22) +- `datadogpy.datadog.util.format:force_to_epoch_seconds` (29:32) +- `datadogpy.datadog.util.format._normalize_tags_with_cache` (36:37) +- `datadogpy.datadog.util.format:construct_path` (25:26) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md new file mode 100644 index 000000000..7f700e05b --- /dev/null +++ b/.codeboarding/on_boarding.md @@ -0,0 +1,419 @@ +```mermaid +graph LR + DogStatsd_Client["DogStatsd Client"] + DogStatsd_Context_Managers["DogStatsd Context Managers"] + Dogshell_CLI_Core["Dogshell CLI Core"] + Dogshell_API_Clients["Dogshell API Clients"] + ThreadStats_Client["ThreadStats Client"] + ThreadStats_AWS_Lambda_Integration["ThreadStats AWS Lambda Integration"] + Datadog_API_Client["Datadog API Client"] + Utility_Core["Utility - Core"] + DogStatsd_Client -- "uses" --> DogStatsd_Context_Managers + DogStatsd_Client -- "depends on" --> Utility_Core + DogStatsd_Context_Managers -- "interacts with" --> DogStatsd_Client + Dogshell_CLI_Core -- "initializes" --> Datadog_API_Client + Dogshell_CLI_Core -- "dispatches to" --> Dogshell_API_Clients + Dogshell_CLI_Core -- "depends on" --> Utility_Core + Dogshell_API_Clients -- "uses" --> Datadog_API_Client + Dogshell_API_Clients -- "depends on" --> Utility_Core + ThreadStats_Client -- "uses" --> Datadog_API_Client + ThreadStats_Client -- "integrates with" --> ThreadStats_AWS_Lambda_Integration + ThreadStats_Client -- "depends on" --> Utility_Core + ThreadStats_AWS_Lambda_Integration -- "uses" --> ThreadStats_Client + ThreadStats_AWS_Lambda_Integration -- "uses" --> Datadog_API_Client + Datadog_API_Client -- "depends on" --> Utility_Core + click DogStatsd_Client href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/DogStatsd Client.md" "Details" + click DogStatsd_Context_Managers href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/DogStatsd Context Managers.md" "Details" + click Dogshell_CLI_Core href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/Dogshell CLI Core.md" "Details" + click Dogshell_API_Clients href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/Dogshell API Clients.md" "Details" + click ThreadStats_Client href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/ThreadStats Client.md" "Details" + click ThreadStats_AWS_Lambda_Integration href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/ThreadStats AWS Lambda Integration.md" "Details" + click Datadog_API_Client href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/Datadog API Client.md" "Details" + click Utility_Core href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/datadogpy/Utility - Core.md" "Details" +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +The `datadogpy` library provides Python clients for interacting with Datadog services. It primarily consists of two main data reporting mechanisms: the `DogStatsd Client` for sending metrics, events, and service checks to a local Datadog Agent via UDP/UDS, and the `Datadog API Client` for direct HTTP API interactions. Additionally, it offers a `ThreadStats Client` for asynchronous metric reporting, especially useful in serverless environments like AWS Lambda, and a `Dogshell CLI` for command-line management of Datadog resources. Core utility components support these functionalities by handling hostname resolution, configuration, compatibility, and data formatting. + +### DogStatsd Client +Provides core functionality for sending metrics, events, and service checks to the Datadog Agent via UDP or UDS, including initialization, socket management, buffering, flushing, and metric aggregation. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogstatsd.base.DogStatsd` (146:1704) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:__init__` (155:503) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:gauge` (923:941) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:count` (967:984) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:histogram` (1050:1067) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:event` (1431:1505) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:service_check` (1507:1550) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:_send_to_server` (1313:1326) +- `datadogpy.datadog.dogstatsd.base.DogStatsd:_xmit_packet` (1343:1406) +- `datadogpy.datadog.dogstatsd.aggregator.Aggregator` (17:118) +- `datadogpy.datadog.dogstatsd.aggregator.Aggregator:__init__` (18:35) +- `datadogpy.datadog.dogstatsd.aggregator.Aggregator:flush_aggregated_metrics` (37:46) +- `datadogpy.datadog.dogstatsd.aggregator.Aggregator:count` (63:66) +- `datadogpy.datadog.dogstatsd.aggregator.Aggregator:gauge` (68:71) +- `datadogpy.datadog.dogstatsd.aggregator.Aggregator:histogram` (93:96) +- `datadogpy.datadog.dogstatsd.metrics.CountMetric:__init__` (19:22) +- `datadogpy.datadog.dogstatsd.metrics.GaugeMetric:__init__` (29:32) +- `datadogpy.datadog.dogstatsd.metrics.SetMetric:__init__` (39:45) +- `datadogpy.datadog.dogstatsd.metrics.SetMetric:get_data` (50:54) +- `datadogpy.datadog.dogstatsd.max_sample_metric.MaxSampleMetric:maybe_keep_sample_work_unsafe` (28:39) +- `datadogpy.datadog.dogstatsd.max_sample_metric.MaxSampleMetric:flush` (44:52) +- `datadogpy.datadog.dogstatsd.max_sample_metric.HistogramMetric:__init__` (56:57) +- `datadogpy.datadog.dogstatsd.max_sample_metric.DistributionMetric:__init__` (61:64) +- `datadogpy.datadog.dogstatsd.max_sample_metric.TimingMetric:__init__` (68:69) +- `datadogpy.datadog.dogstatsd.max_sample_metric_context.MaxSampleMetricContexts:sample` (21:36) +- `datadogpy.datadog:initialize` (full file reference) + + +### DogStatsd Context Managers +Provides context managers and decorators for automatically timing code blocks and managing distributed tracing contexts for DogStatsd metrics. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator` (21:93) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:__call__` (43:67) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:__enter__` (69:73) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:__exit__` (75:77) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:start` (89:90) +- `datadogpy.datadog.dogstatsd.context.TimedContextManagerDecorator:stop` (92:93) +- `datadogpy.datadog.dogstatsd.context.DistributedContextManagerDecorator:__init__` (102:111) + + +### Dogshell CLI Core +The main entry point for the `dogshell` command-line application, handling argument parsing, configuration loading, error reporting, and dispatching commands to specific CLI clients. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogshell.wrap:main` (407:514) +- `datadogpy.datadog.dogshell.wrap:parse_options` (252:404) +- `datadogpy.datadog.dogshell.wrap:execute` (105:166) +- `datadogpy.datadog.dogshell.wrap:poll_proc` (90:102) +- `datadogpy.datadog.dogshell.wrap:build_event_body` (192:232) +- `datadogpy.datadog.dogshell.common:print_err` (13:18) +- `datadogpy.datadog.dogshell.common:report_errors` (21:30) +- `datadogpy.datadog.dogshell.common:report_warnings` (33:42) +- `datadogpy.datadog.dogshell.common.DogshellConfig:load` (46:122) +- `datadogpy.datadog.util.cli:comma_list` (12:16) +- `datadogpy.datadog.util.cli:comma_set` (19:20) +- `datadogpy.datadog.util.cli:comma_list_or_empty` (23:27) +- `datadogpy.datadog.util.cli:list_of_ints_and_strs` (48:55) +- `datadogpy.datadog.util.cli:set_of_ints` (58:59) +- `datadogpy.datadog.util.cli:parse_date_as_epoch_timestamp` (74:75) +- `datadogpy.datadog.util.cli:parse_date` (83:152) + + +### Dogshell API Clients +Provides various client classes for interacting with specific Datadog API resources via the command-line interface, encapsulating logic for CRUD operations on different Datadog services. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.dogshell.downtime.DowntimeClient:_schedule_downtime` (67:76) +- `datadogpy.datadog.dogshell.downtime.DowntimeClient:_update_downtime` (79:90) +- `datadogpy.datadog.dogshell.downtime.DowntimeClient:_cancel_downtime` (93:98) +- `datadogpy.datadog.dogshell.downtime.DowntimeClient:_show_downtime` (101:110) +- `datadogpy.datadog.dogshell.downtime.DowntimeClient:_show_all_downtime` (113:122) +- `datadogpy.datadog.dogshell.downtime.DowntimeClient:_cancel_downtime_by_scope` (125:132) +- `datadogpy.datadog.dogshell.host.HostClient:_mute` (40:49) +- `datadogpy.datadog.dogshell.host.HostClient:_unmute` (52:61) +- `datadogpy.datadog.dogshell.tag.TagClient:_add` (48:62) +- `datadogpy.datadog.dogshell.tag.TagClient:_replace` (65:79) +- `datadogpy.datadog.dogshell.tag.TagClient:_show` (82:112) +- `datadogpy.datadog.dogshell.tag.TagClient:_detach` (115:120) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_create` (178:233) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_file_create` (236:246) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_update` (249:302) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_file_update` (305:316) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_show` (319:332) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_show_all` (335:352) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete` (355:365) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete_many` (368:378) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_delete_timeframe` (381:394) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_can_delete` (397:408) +- `datadogpy.datadog.dogshell.service_level_objective.ServiceLevelObjectiveClient:_history` (411:422) +- `datadogpy.datadog.dogshell.comment.CommentClient:_post` (43:69) +- `datadogpy.datadog.dogshell.comment.CommentClient:_update` (72:98) +- `datadogpy.datadog.dogshell.comment.CommentClient:_reply` (101:128) +- `datadogpy.datadog.dogshell.comment.CommentClient:_show` (131:152) +- `datadogpy.datadog.dogshell.service_check.ServiceCheckClient:_check` (35:55) +- `datadogpy.datadog.dogshell.monitor.MonitorClient` (16:474) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_post` (171:208) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_file_post` (211:238) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_update` (241:291) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_file_update` (294:323) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_show` (326:339) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_show_all` (342:374) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_delete` (377:383) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_mute_all` (390:399) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_unmute_all` (402:407) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_mute` (410:419) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_unmute` (422:430) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_can_delete` (433:440) +- `datadogpy.datadog.dogshell.monitor.MonitorClient:_validate` (443:474) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_post` (141:153) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_update` (156:169) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_show` (172:184) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_show_all` (187:198) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_delete` (201:213) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_show_dashboards` (216:228) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_show_dashboards_v2` (231:243) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_add_dashboards` (246:259) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_add_dashboards_v2` (262:275) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_update_dashboards` (278:291) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_update_dashboards_v2` (294:307) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_delete_dashboards` (310:323) +- `datadogpy.datadog.dogshell.dashboard_list.DashboardListClient:_delete_dashboards_v2` (326:339) +- `datadogpy.datadog.dogshell.dashboard.DashboardClient:_post` (91:117) +- `datadogpy.datadog.dogshell.dashboard.DashboardClient:_update` (120:146) +- `datadogpy.datadog.dogshell.dashboard.DashboardClient:_show` (149:159) +- `datadogpy.datadog.dogshell.dashboard.DashboardClient:_delete` (162:167) +- `datadogpy.datadog.dogshell.hosts.HostsClient:_list` (69:88) +- `datadogpy.datadog.dogshell.hosts.HostsClient:_totals` (91:100) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_pull` (118:119) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_pull_all` (122:156) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_new_file` (159:178) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_write_dash_to_file` (181:204) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_push` (207:253) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_post` (256:271) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_update` (274:294) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_show` (297:310) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_show_all` (313:330) +- `datadogpy.datadog.dogshell.timeboard.TimeboardClient:_delete` (333:338) +- `datadogpy.datadog.dogshell.metric.MetricClient:_post` (43:72) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_pull` (116:117) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_push` (121:152) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_write_screen_to_file` (155:175) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_post` (178:199) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_update` (202:224) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_show` (233:246) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_delete` (249:255) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_share` (258:266) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_revoke` (269:277) +- `datadogpy.datadog.dogshell.screenboard.ScreenboardClient:_new_file` (280:298) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_show_rule` (157:161) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_show_all_rules` (164:175) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_create_rule` (178:192) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_update_rule` (195:209) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_delete_rule` (212:219) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_list_signals` (222:244) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_get_signal` (247:254) +- `datadogpy.datadog.dogshell.security_monitoring.SecurityMonitoringClient:_change_triage_state` (257:264) +- `datadogpy.datadog.dogshell.search.SearchClient:_query` (25:43) +- `datadogpy.datadog.dogshell.event.EventClient:_post` (117:157) +- `datadogpy.datadog.dogshell.event.EventClient:_show` (160:171) +- `datadogpy.datadog.dogshell.event.EventClient:_stream` (174:201) +- `datadogpy.datadog.dogshell.event:print_event` (32:33) +- `datadogpy.datadog.dogshell.event:prettyprint_event_details` (36:37) +- `datadogpy.datadog.dogshell.event:print_event_details` (40:41) + + +### ThreadStats Client +A client for sending metrics and events in multi-threaded or asynchronous environments, managing flushing and reporting of aggregated data, particularly useful for serverless functions. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.base.ThreadStats` (41:511) +- `datadogpy.datadog.threadstats.base.ThreadStats:start` (85:164) +- `datadogpy.datadog.threadstats.base.ThreadStats:stop` (166:172) +- `datadogpy.datadog.threadstats.base.ThreadStats:event` (174:212) +- `datadogpy.datadog.threadstats.base.ThreadStats:gauge` (214:228) +- `datadogpy.datadog.threadstats.base.ThreadStats:set` (230:241) +- `datadogpy.datadog.threadstats.base.ThreadStats:increment` (243:255) +- `datadogpy.datadog.threadstats.base.ThreadStats:decrement` (257:268) +- `datadogpy.datadog.threadstats.base.ThreadStats:histogram` (270:282) +- `datadogpy.datadog.threadstats.base.ThreadStats:distribution` (284:296) +- `datadogpy.datadog.threadstats.base.ThreadStats:timing` (298:307) +- `datadogpy.datadog.threadstats.base.ThreadStats:timer` (310:335) +- `datadogpy.datadog.threadstats.base.ThreadStats:timed` (337:365) +- `datadogpy.datadog.threadstats.base.ThreadStats:flush` (367:418) +- `datadogpy.datadog.threadstats.base.ThreadStats:_get_aggregate_metrics_and_dists` (420:458) +- `datadogpy.datadog.threadstats.base.ThreadStats:_get_aggregate_events` (460:463) +- `datadogpy.datadog.threadstats.base.ThreadStats:_start_flush_thread` (465:487) +- `datadogpy.datadog.threadstats.base.ThreadStats:_start_flush_greenlet` (489:511) +- `datadogpy.datadog.threadstats.metrics.Histogram:__init__` (109:120) +- `datadogpy.datadog.threadstats.metrics.Histogram:add_point` (122:130) +- `datadogpy.datadog.threadstats.metrics.Histogram:flush` (132:155) +- `datadogpy.datadog.threadstats.events.EventsAggregator:add_event` (19:22) + + +### ThreadStats AWS Lambda Integration +Provides specific integration for Datadog ThreadStats within AWS Lambda environments, enabling automatic metric collection and handling the lifecycle of the ThreadStats client in a serverless context. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator` (22:77) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:__call__` (71:77) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:_enter` (35:50) +- `datadogpy.datadog.threadstats.aws_lambda._LambdaDecorator:_close` (53:69) +- `datadogpy.datadog.threadstats.aws_lambda:_get_lambda_stats` (84:90) +- `datadogpy.datadog.threadstats.aws_lambda:lambda_metric` (93:95) + + +### Datadog API Client +The foundational component for all interactions with the Datadog HTTP API, managing API key authentication, request submission, error handling, retry logic, and providing interfaces for various Datadog API endpoints. + + +**Related Classes/Methods**: + +- `datadogpy.datadog.api.api_client.APIClient` (21:290) +- `datadogpy.datadog.api.api_client.APIClient:submit` (48:236) +- `datadogpy.datadog.api.api_client.APIClient:_get_http_client` (38:45) +- `datadogpy.datadog.api.api_client.APIClient:_should_submit` (239:280) +- `datadogpy.datadog.api.http_client.RequestClient` (81:126) +- `datadogpy.datadog.api.http_client.RequestClient:request` (91:126) +- `datadogpy.datadog.api.http_client.URLFetchClient` (129:183) +- `datadogpy.datadog.api.http_client.URLFetchClient:request` (135:170) +- `datadogpy.datadog.api.http_client.URLFetchClient:raise_on_status` (173:183) +- `datadogpy.datadog.api.http_client.Urllib3Client` (186:235) +- `datadogpy.datadog.api.http_client.Urllib3Client:request` (195:225) +- `datadogpy.datadog.api.http_client.Urllib3Client:raise_on_status` (228:235) +- `datadogpy.datadog.api.resources.CreateableAPIResource:create` (17:50) +- `datadogpy.datadog.api.resources.SendableAPIResource:send` (59:92) +- `datadogpy.datadog.api.resources.UpdatableAPIResource:update` (101:119) +- `datadogpy.datadog.api.resources.CustomUpdatableAPIResource:update` (128:155) +- `datadogpy.datadog.api.resources.DeletableAPIResource:delete` (164:176) +- `datadogpy.datadog.api.resources.GetableAPIResource:get` (185:200) +- `datadogpy.datadog.api.resources.ListableAPIResource:get_all` (209:220) +- `datadogpy.datadog.api.resources.ListableAPISubResource:get_items` (229:247) +- `datadogpy.datadog.api.resources.AddableAPISubResource:add_items` (256:279) +- `datadogpy.datadog.api.resources.UpdatableAPISubResource:update_items` (288:311) +- `datadogpy.datadog.api.resources.DeletableAPISubResource:delete_items` (320:343) +- `datadogpy.datadog.api.resources.SearchableAPIResource:_search` (352:363) +- `datadogpy.datadog.api.resources.ActionAPIResource:_trigger_class_action` (372:407) +- `datadogpy.datadog.api.resources.ActionAPIResource:_trigger_action` (410:436) +- `datadogpy.datadog.api.resources.UpdatableAPISyntheticsSubResource:update_synthetics_items` (445:468) +- `datadogpy.datadog.api.resources.UpdatableAPISyntheticsResource:update_synthetics` (477:495) +- `datadogpy.datadog.api.resources.ActionAPISyntheticsResource:_trigger_synthetics_class_action` (504:539) +- `datadogpy.datadog.api.metrics.Metric:list` (22:39) +- `datadogpy.datadog.api.metrics.Metric:send` (54:111) +- `datadogpy.datadog.api.metrics.Metric:query` (114:147) +- `datadogpy.datadog.api.distributions.Distribution:send` (15:45) +- `datadogpy.datadog.api.tags.Tag:create` (21:36) +- `datadogpy.datadog.api.tags.Tag:update` (39:54) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:list` (16:22) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:delete` (25:34) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:create` (37:67) +- `datadogpy.datadog.api.gcp_integration.GcpIntegration:update` (70:93) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:get_all` (34:43) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:get` (46:55) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:create` (58:67) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:update` (70:81) +- `datadogpy.datadog.api.security_monitoring_rules.SecurityMonitoringRule:delete` (84:93) +- `datadogpy.datadog.api.monitors.Monitor` (14:157) +- `datadogpy.datadog.api.monitors.Monitor:get` (29:45) +- `datadogpy.datadog.api.monitors.Monitor:get_all` (48:72) +- `datadogpy.datadog.api.monitors.Monitor:mute` (75:88) +- `datadogpy.datadog.api.monitors.Monitor:unmute` (91:103) +- `datadogpy.datadog.api.monitors.Monitor:mute_all` (106:112) +- `datadogpy.datadog.api.monitors.Monitor:unmute_all` (115:121) +- `datadogpy.datadog.api.monitors.Monitor:search` (124:130) +- `datadogpy.datadog.api.monitors.Monitor:search_groups` (133:139) +- `datadogpy.datadog.api.monitors.Monitor:can_delete` (142:148) +- `datadogpy.datadog.api.monitors.Monitor:validate` (151:157) +- `datadogpy.datadog.api.users.User:invite` (30:50) +- `datadogpy.datadog.api.screenboards.Screenboard:share` (29:38) +- `datadogpy.datadog.api.screenboards.Screenboard:revoke` (41:50) +- `datadogpy.datadog.api.events.Event:create` (18:69) +- `datadogpy.datadog.api.events.Event:query` (72:95) +- `datadogpy.datadog.api.infrastructure.Infrastructure:search` (15:28) +- `datadogpy.datadog.api.synthetics.Synthetics:get_test` (31:45) +- `datadogpy.datadog.api.synthetics.Synthetics:get_all_tests` (48:61) +- `datadogpy.datadog.api.synthetics.Synthetics:get_devices` (64:75) +- `datadogpy.datadog.api.synthetics.Synthetics:get_locations` (78:89) +- `datadogpy.datadog.api.synthetics.Synthetics:get_results` (92:106) +- `datadogpy.datadog.api.synthetics.Synthetics:get_result` (109:126) +- `datadogpy.datadog.api.synthetics.Synthetics:create_test` (129:163) +- `datadogpy.datadog.api.synthetics.Synthetics:edit_test` (166:178) +- `datadogpy.datadog.api.synthetics.Synthetics:start_or_pause_test` (181:196) +- `datadogpy.datadog.api.synthetics.Synthetics:delete_test` (199:214) +- `datadogpy.datadog.api.roles.Roles:update` (32:41) +- `datadogpy.datadog.api.roles.Roles:assign_permission` (44:56) +- `datadogpy.datadog.api.roles.Roles:unassign_permission` (59:71) +- `datadogpy.datadog.api.service_checks.ServiceCheck:check` (15:45) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:list` (24:30) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:create` (33:45) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:delete` (48:57) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:update_host_filters` (60:72) +- `datadogpy.datadog.api.azure_integration.AzureIntegration:update` (75:91) +- `datadogpy.datadog.api.logs.Logs:list` (16:22) +- `datadogpy.datadog.api.downtimes.Downtime:cancel_downtime_by_scope` (29:38) +- `datadogpy.datadog.api.hosts.Host:mute` (15:35) +- `datadogpy.datadog.api.hosts.Host:unmute` (38:48) +- `datadogpy.datadog.api.hosts.Hosts:search` (59:82) +- `datadogpy.datadog.api.hosts.Hosts:totals` (85:94) +- `datadogpy.datadog.api.hosts.Hosts:get_all` (97:135) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:list_log_services` (16:23) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:add_log_lambda_arn` (26:37) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:save_services` (40:50) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:delete_config` (53:64) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:check_lambda` (67:85) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:check_services` (88:101) +- `datadogpy.datadog.api.aws_log_integration.AwsLogsIntegration:list` (104:111) +- `datadogpy.datadog.api.metadata.Metadata:get` (16:27) +- `datadogpy.datadog.api.metadata.Metadata:update` (30:64) +- `datadogpy.datadog.api.graphs.Graph:create` (16:34) +- `datadogpy.datadog.api.graphs.Graph:status` (37:52) +- `datadogpy.datadog.api.graphs.Embed:enable` (63:72) +- `datadogpy.datadog.api.graphs.Embed:revoke` (75:84) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:create` (30:38) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:get` (41:50) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:get_all` (53:89) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:update` (92:101) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:delete` (104:113) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:bulk_delete` (116:133) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:delete_many` (136:151) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:can_delete` (154:174) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:history` (177:204) +- `datadogpy.datadog.api.service_level_objectives.ServiceLevelObjective:search` (207:213) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:list` (30:36) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:create` (39:97) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:update` (100:213) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:delete` (216:225) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:list_namespace_rules` (228:235) +- `datadogpy.datadog.api.aws_integration.AwsIntegration:generate_new_external_id` (238:248) +- `datadogpy.datadog.api.security_monitoring_signals.SecurityMonitoringSignal:get` (30:39) +- `datadogpy.datadog.api.security_monitoring_signals.SecurityMonitoringSignal:get_all` (42:58) +- `datadogpy.datadog.api.security_monitoring_signals.SecurityMonitoringSignal:change_triage_state` (61:84) + + +### Utility - Core +Provides essential utility functions for the library, including hostname determination, configuration file management, Python version compatibility, and data formatting (tags, JSON, time series). + + +**Related Classes/Methods**: + +- `datadogpy.datadog.util.hostname:get_hostname` (45:125) +- `datadogpy.datadog.util.hostname.GCE:get_hostname` (185:190) +- `datadogpy.datadog.util.hostname.EC2:get_tags` (201:240) +- `datadogpy.datadog.util.hostname.EC2:get_instance_id` (301:305) +- `datadogpy.datadog.util.compat:is_p3k` (103:107) +- `datadogpy.datadog.util.compat:is_higher_py32` (110:114) +- `datadogpy.datadog.util.compat:is_higher_py35` (117:121) +- `datadogpy.datadog.util.compat:conditional_lru_cache` (131:145) +- `datadogpy.datadog.util.config:skip_leading_wsp` (40:45) +- `datadogpy.datadog.util.config:_windows_config_path` (66:71) +- `datadogpy.datadog.util.config:_unix_config_path` (74:78) +- `datadogpy.datadog.util.config:_mac_config_path` (81:86) +- `datadogpy.datadog.util.config:get_config_path` (89:103) +- `datadogpy.datadog.util.config:get_config` (106:130) +- `datadogpy.datadog.util.format:normalize_tags` (40:43) +- `datadogpy.datadog.util.format:pretty_json` (17:18) +- `datadogpy.datadog.util.format:validate_cardinality` (46:53) +- `datadogpy.datadog.util.format.format_points` (full file reference) +- `datadogpy.datadog.util.format.construct_url` (21:22) +- `datadogpy.datadog.util.format.force_to_epoch_seconds` (29:32) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file