content large_stringlengths 3 20.5k | url large_stringlengths 54 193 | branch large_stringclasses 4
values | source large_stringclasses 42
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
Since, for example, macOS 10.11 may provide a different version of Python than macOS 10.12, system builds on each of these platforms may produce different Agent binaries. If this doesn't matter to you—perhaps you just want to contribute a quick bugfix—do a System build; it's easier and faster than an Embedded build. Sy... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/setup/manual.md | main | datadog-agent | [
-0.02359849028289318,
0.0015989448875188828,
-0.005588230211287737,
-0.007797259837388992,
0.0206559170037508,
-0.09947548806667328,
-0.07526891678571701,
0.042931027710437775,
-0.04436007887125015,
-0.04495292529463768,
0.03760411962866783,
-0.040644120424985886,
0.058174021542072296,
0.0... | -0.002956 |
environment](../tutorials/dev/env.md) approach is recommended. /// [Microsoft Visual Studio Code](https://code.visualstudio.com/download) with the [devcontainer plugin](https://code.visualstudio.com/docs/remote/containers) allow to use a container as remote development environment in vscode. It simplify and isolate the... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/setup/manual.md | main | datadog-agent | [
0.034388743340969086,
-0.061162710189819336,
-0.018712442368268967,
-0.012290089391171932,
-0.014225641265511513,
0.016587762162089348,
-0.11394935846328735,
0.052067872136831284,
-0.001776176504790783,
0.011294199153780937,
-0.023884836584329605,
-0.06378325819969177,
-0.058039747178554535,... | 0.012985 |
# Set up development requirements ----- ## Tooling The `dda` [CLI](https://datadoghq.dev/datadog-agent-dev/) is required in all aspects of development and must be available on `PATH`. <<>> ## Docker [Docker](https://docs.docker.com/get-started/docker-overview/) is required for both running the developer environment and... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/setup/required.md | main | datadog-agent | [
0.0067917159758508205,
-0.008252669125795364,
0.04432517662644386,
-0.07781195640563965,
-0.036385878920555115,
-0.06582694500684738,
-0.04717913269996643,
0.01381387747824192,
-0.038710881024599075,
0.0204016026109457,
0.0034275406505912542,
-0.0868459939956665,
0.045251596719026566,
0.01... | -0.017198 |
# Creating go modules in the Agent project \*\*The Datadog Agent is not meant to be imported as a Go library.\*\* However, certain parts of it can be exposed as a library by making use of [nested Go modules](https://github.com/go-modules-by-example/index/blob/master/009\_submodules/README.md). This allows for exposing ... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/go/modules.md | main | datadog-agent | [
-0.017563151195645332,
-0.002743896096944809,
-0.07231460511684418,
-0.03825173154473305,
-0.008283153176307678,
0.010148006491363049,
0.015061059966683388,
0.035852786153554916,
-0.04498840123414993,
-0.049530934542417526,
0.08362520486116409,
0.00396669702604413,
0.07347039133310318,
0.0... | -0.018394 |
inv release.finish` The `release.tag-modules` task is also called by the `release.tag-version` invoke task, using the same commit as the main module, with a tag of the form `path/to/module/v0.X.Y`. /// ## The `modules.yml` file The `modules.yml` file gathers all go module configurations. Each module is listed even if t... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/go/modules.md | main | datadog-agent | [
0.008375978097319603,
0.019126031547784805,
-0.06537184864282608,
-0.025205589830875397,
0.04219662770628929,
-0.0060137673281133175,
0.006567030213773251,
0.03857868164777756,
-0.07603944838047028,
-0.07156546413898468,
0.10329780727624893,
0.03857734054327011,
-0.026780907064676285,
0.09... | -0.008099 |
# Agent Configuration This doc describes how to define new configuration parameters for the Agent. 1. Define your config. 2. Add it to the config template (optional). 3. Use your config in your code. 4. Request a review from the Agent configuration team (team/agent-configuration) If you have any questions, head over to... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/go/config.md | main | datadog-agent | [
0.007184459362179041,
-0.021839747205376625,
-0.08813302218914032,
0.034702084958553314,
-0.02097424678504467,
-0.027705175802111626,
0.01673518307507038,
0.058654990047216415,
-0.12018077075481415,
-0.026192782446742058,
0.06120800971984863,
-0.049417294561862946,
0.10760537534952164,
-0.... | 0.06548 |
# How to run unit tests ----- The `dda inv test` command runs Go tests and is a thin wrapper around [gotestsum](https://github.com/gotestyourself/gotestsum). ## Test selection The Go module to test may be selected with the `-m`/`--module` flag using a relative path, defaulting to `.`. The `-t`/`--targets` flag is used ... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/test/unit.md | main | datadog-agent | [
-0.03024960681796074,
-0.01268136128783226,
-0.08827246725559235,
-0.026255406439304352,
0.07558118551969528,
-0.09109803289175034,
-0.032722409814596176,
0.010254877619445324,
-0.0452798493206501,
-0.045406099408864975,
0.09665931016206741,
-0.03703521564602852,
-0.05174217373132706,
0.04... | 0.064894 |
# Running E2E tests End-to-End (E2E) tests validate complete user workflows in production-like environments with real infrastructure and external services. The Datadog Agent uses the [test-infra-definitions](https://github.com/DataDog/datadog-agent/test/e2e-framework) framework to provision and manage test environments... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/test/e2e.md | main | datadog-agent | [
-0.034417685121297836,
-0.03300763666629791,
0.013514471240341663,
-0.015193256549537182,
0.0027610782999545336,
-0.12489002197980881,
-0.07255512475967407,
0.050417859107255936,
-0.05078592151403427,
-0.011430551297962666,
0.02905595302581787,
-0.07801811397075653,
0.03874918445944786,
0.... | 0.009692 |
Local packaging is curently limited to DEB packages, only for Linux and Macos computers. This method relies on updating an existing agent package with the local Go binaries. As a consequence, this is incompatible with tests related to the agent packaging or the python integration. /// From a developer environment (see ... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/test/e2e.md | main | datadog-agent | [
0.00916252564638853,
0.00391762051731348,
0.00949804950505495,
-0.05634327605366707,
0.04414036497473717,
-0.10639001429080963,
-0.05483836308121681,
0.034718576818704605,
-0.09733735024929047,
0.022801218554377556,
0.07518107444047928,
-0.10423833876848221,
-0.013724973425269127,
0.039087... | -0.014259 |
verification - Secure communication validation ## Best Practices ### Test Design - \*\*Single Responsibility\*\*: Each test should validate one specific workflow - \*\*Clear Assertions\*\*: Use descriptive assertion messages - \*\*Proper Timeouts\*\*: Set appropriate timeouts for operations - \*\*Resource Management\*\... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/test/e2e.md | main | datadog-agent | [
-0.0548725351691246,
0.04566729813814163,
-0.059501439332962036,
0.020280953496694565,
0.012038213200867176,
-0.07629445195198059,
-0.051626674830913544,
-0.02913891151547432,
-0.04739532992243767,
-0.0010033327853307128,
-0.008581211790442467,
-0.05450727045536041,
0.03369853273034096,
0.... | 0.124495 |
# How to perform static analysis ----- CI enforces static analysis checks for code, configuration, documentation, and more. ## Go Go code can be analyzed with the `dda inv linter.go` command. This uses [golangci-lint](https://github.com/golangci/golangci-lint) which is an aggregator for several linters. The configurati... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/test/static-analysis.md | main | datadog-agent | [
-0.05460427701473236,
0.0203722957521677,
-0.07983460277318954,
0.007071488071233034,
0.012090509757399559,
-0.0668787881731987,
-0.00048422737745568156,
0.032582640647888184,
-0.06813904643058777,
-0.04894668608903885,
0.06396625190973282,
-0.0004499917267821729,
0.008203842677175999,
0.0... | 0.1049 |
# Windows Troubleshooting Prior to 7.23, Agent binaries (Datadog Agent, Process Agent, Trace Agent, etc.) on Windows contain symbol information. Starting from 7.23, Agent binaries on Windows have debugging information stripped. The original files are packed in a file called debug package. ## Prerequisite To debug Agent... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/debug-agents/windows.md | main | datadog-agent | [
0.0023614747915416956,
0.012888307683169842,
-0.04473119601607323,
-0.011567175388336182,
0.008404124528169632,
-0.011581996455788612,
0.001958225155249238,
-0.021668488159775734,
-0.033620890229940414,
0.025393148884177208,
0.0832393616437912,
-0.05427277460694313,
-0.011229585856199265,
... | 0.071519 |
# Linux Troubleshooting ## Generating and using core dumps on Linux ### Generating core dumps on Agent crashes There are two ways to generate core dumps when the Agent crashes on Linux. Starting on version 7.27 the Datadog Agent includes the `go\_core\_dump` option that, when enabled, makes any Agent process generate a... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/debug-agents/linux.md | main | datadog-agent | [
0.018852651119232178,
-0.04881676286458969,
-0.04539336636662483,
-0.023696279153227806,
0.06166301667690277,
-0.02440525032579899,
-0.060225632041692734,
0.09090261906385422,
-0.06344816088676453,
0.04977274313569069,
-0.01199579518288374,
-0.05477873608469963,
-0.00637661200016737,
-0.01... | 0.092385 |
# Tools to troubleshoot a running Agent This page attempts to list useful tools and resources to troubleshoot and profile a running Agent. ## [pprof](https://golang.org/pkg/net/http/pprof/) The Agent exposes pprof's HTTP server on port `5000` by default. Through the pprof port you can get profiles (CPU, memory, etc) on... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/debug-agents/index.md | main | datadog-agent | [
-0.004573589190840721,
0.020748719573020935,
-0.15023721754550934,
-0.0032945626880973577,
-0.039483096450567245,
-0.04630249738693237,
0.01213746890425682,
0.07296320796012878,
-0.04920089244842529,
-0.005261954385787249,
0.07271184027194977,
-0.00047575312783010304,
-0.01521395891904831,
... | 0.088206 |
# Go tracking and troubleshooting To investigate the Go portion of the process memory, you can use the usual and expected tooling available to any Go binary. If you encounter a leak in the Agent process as seen in the process RSS, review the Go memory profile. If everything is okay, the leak may be elsewhere. The usual... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/memory-profiling/go.md | main | datadog-agent | [
0.017368678003549576,
0.009513352066278458,
-0.11920882016420364,
0.011608675122261047,
0.0018938726279884577,
-0.035943351686000824,
0.003370258491486311,
0.05519628897309303,
-0.004588289186358452,
0.01582079939544201,
0.041179314255714417,
-0.0025066169910132885,
-0.034417323768138885,
... | 0.038223 |
will help you get started, but there is more information available in the links below. ### Further Reading - [Julia Evans: go profiling](https://jvns.ca/blog/2017/09/24/profiling-go-with-pprof/) - [Detectify: memory leak investigation](https://blog.detectify.com/2019/09/05/how-we-tracked-down-a-memory-leak-in-one-of-ou... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/memory-profiling/go.md | main | datadog-agent | [
0.03566119819879532,
-0.045110512524843216,
-0.09049317985773087,
0.0268324613571167,
0.028649073094129562,
-0.006836947984993458,
0.068283811211586,
0.08671972900629044,
-0.03053932823240757,
0.02134246751666069,
0.0529802031815052,
0.03213011845946312,
-0.06775830686092377,
0.03933529183... | 0.114377 |
# Python tracking and troubleshooting Python, another runtime in the Agent process, is also garbage collected. Datadog offers two tools with the Agent that can help you identify memory issues: - Python memory telemetry (Python 3 only) - Tracemalloc - Pympler ### Python memory telemetry Python memory telemetry hooks int... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/memory-profiling/python.md | main | datadog-agent | [
0.041854970157146454,
-0.0009397247922606766,
-0.0828172117471695,
0.05454006791114807,
-0.04965319111943245,
-0.12859229743480682,
-0.008031068369746208,
0.05472968518733978,
0.006688173394650221,
0.012602201662957668,
0.012415756471455097,
0.020973743870854378,
0.024861793965101242,
-0.0... | 0.054409 |
is to allow us to more easily identify sources of allocations without the interference of the GC. Note that the GC is not permanently disabled, this is only enforced during the check run while tracemalloc is tracking allocations. Default: disabled. - `combine`: whether or not to aggregate over all traceback frames. use... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/memory-profiling/python.md | main | datadog-agent | [
-0.04586891084909439,
-0.04347837716341019,
-0.06655218452215195,
0.014872261323034763,
0.052005574107170105,
-0.07236803323030472,
0.04574074596166611,
0.008321112021803856,
-0.014929557219147682,
-0.012736104428768158,
0.03513992950320244,
0.05408833175897598,
-0.024072883650660515,
-0.0... | 0.088437 |
Troubleshooting Agent Memory Usage The Agent process presents unusual challenges when it comes to memory profiling and investigation. Multiple memory spaces, with various heaps coming from multiple different runtimes, can make identifying memory issues tricky. The Agent has three distinct memory spaces, each handled in... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/memory-profiling/overview.md | main | datadog-agent | [
0.04545339569449425,
0.012484143488109112,
-0.1108592301607132,
0.03593672066926956,
-0.018268434330821037,
-0.061427339911460876,
-0.02675621211528778,
0.03190168738365173,
-0.010775735601782799,
-0.04807783663272858,
0.0018127006478607655,
0.006215537898242474,
0.015185192227363586,
0.05... | 0.038466 |
# C/C++ tracking and troubleshooting Allocations in the Datadog cgo and [RTLoader](https://github.com/DataDog/datadog-agent/blob/main/rtloader/common/rtloader\_mem.h) code have been wrapped by a set of helper functions that help keep accounting with regard to the number of allocations made and freed, as well as their r... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/memory-profiling/c++.md | main | datadog-agent | [
-0.021909678354859352,
0.031330130994319916,
-0.012324931100010872,
0.08266126364469528,
-0.0038812800776213408,
-0.025039570406079292,
0.0005130980862304568,
0.03159460797905922,
0.013391449116170406,
0.02246914617717266,
0.042715027928352356,
-0.014163327403366566,
0.01749112457036972,
0... | 0.075107 |
# How to build agent distribution packages --- ## Intro ### What are distribution packages ? By "distribution package", we mean an artifact used by end users to install the Agent on their system. The format is OS-specific: | OS | Package Format | | ------- | ------------------------------------------- | | Linux | `.deb... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/build/distributions.md | main | datadog-agent | [
-0.08434689044952393,
-0.0162105243653059,
-0.026009541004896164,
-0.05401655659079552,
0.040746793150901794,
-0.036062560975551605,
0.0014082671841606498,
-0.0038986029103398323,
-0.05404885113239288,
-0.022233018651604652,
0.0730169266462326,
-0.08940587937831879,
0.020629022270441055,
-... | 0.132751 |
the root folder of a clone of the `datadog-agent` repo. 1. Run the following command, which will create a container for the previously-mentioned image, and run the `omnibus.build` task inside. ```bash docker run -v "$PWD:/go/src/github.com/DataDog/datadog-agent" -v "/tmp/omnibus:/omnibus" -v "/tmp/opt/datadog-agent:/op... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/build/distributions.md | main | datadog-agent | [
-0.03758564963936806,
-0.001981870736926794,
-0.04733739793300629,
-0.05123215913772583,
0.01661130040884018,
-0.11853612214326859,
-0.07537055760622025,
0.008886960335075855,
0.016822224482893944,
0.009906555525958538,
0.02443384751677513,
-0.0005254899733699858,
0.05535975471138954,
0.01... | -0.018877 |
available. This image, contrary to the main `datadog/agent-buildimages-linux` image, is not multi-arch - thus there are two flavors depending on the CPU architecture of the host machine: - For `x86\_64`/`amd64`: [`datadog/agent-buildimages-rpm\_x64`](https://hub.docker.com/r/datadog/agent-buildimages-rpm\_x64) - For `a... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/build/distributions.md | main | datadog-agent | [
-0.0025228888262063265,
0.03154393658041954,
0.004058932885527611,
-0.061015401035547256,
0.0053857765160501,
-0.08950797468423843,
-0.10999896377325058,
0.0023362631909549236,
-0.033349957317113876,
0.025474369525909424,
0.005055893678218126,
-0.07346674054861069,
0.03250308334827423,
-0.... | 0.013165 |
# How to build standalone agent binaries ----- ## Building agent binaries The Core Agent is built using the `dda inv agent.build` command. ``` dda inv agent.build --build-exclude=systemd ``` Running this command will: - Discard any changes done in `bin/agent/dist`. - Build the Agent and write the binary to `bin/agent/a... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/build/standalone.md | main | datadog-agent | [
-0.030207140371203423,
-0.015531428158283234,
-0.07053514569997787,
-0.0639754980802536,
0.0033132003154605627,
-0.0598597526550293,
-0.03775328770279884,
0.032896749675273895,
-0.06042008474469185,
0.010739847086369991,
0.0456421822309494,
-0.07894634455442429,
0.04502482712268829,
-0.023... | 0.008058 |
/// details | Under the hood open: False type: info Making a bundle - combining functionality from multiple binaries - just corresponds to building an agent binary including the source code from the others. Like other features, this is accomplished through Go build constraints. Under the hood, building with a `--bundle... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/how-to/build/standalone.md | main | datadog-agent | [
-0.04779578372836113,
0.0056748040951788425,
-0.06306588649749756,
-0.06063004955649376,
0.07384689152240753,
-0.04428902268409729,
0.030733266845345497,
0.04198642447590828,
-0.06820840388536453,
-0.036563046276569366,
0.056027721613645554,
-0.03143395483493805,
0.015156926587224007,
0.01... | 0.059526 |
# Overview of components The Agent is structured as a collection of components working together. Depending on how the binary is built, and how it is invoked, different components may be instantiated. ## What is a component? The goal of a component is to encapsulate a particular piece of logic/feature and provide a clea... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/overview.md | main | datadog-agent | [
-0.013077323324978352,
-0.0026250085793435574,
-0.0417742095887661,
0.006584334187209606,
-0.029611876234412193,
0.015641460195183754,
-0.006099143531173468,
0.010711712762713432,
0.017835337668657303,
-0.036683589220047,
0.020857101306319237,
-0.03784940764307976,
0.039759524166584015,
0.... | 0.129061 |
# Creating a bundle A bundle is a grouping of related components. The goal of a bundle is to ease the usage of multiple components working together to constitute a product. One example is `DogStatsD`, a server to receive metrics locally from customer apps. `DogStatsD` is composed of 9+ components, but at the binary lev... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/creating-bundles.md | main | datadog-agent | [
-0.06964699178934097,
-0.0326344296336174,
-0.034949980676174164,
-0.003745767753571272,
0.004270200617611408,
0.00665128231048584,
0.02888229861855507,
0.10176081955432892,
-0.03213735669851303,
-0.006916641723364592,
0.1118096336722374,
-0.02122328244149685,
0.062087174504995346,
0.07137... | 0.044662 |
# FAQ ## Optional Component You might need to express the fact that some of your dependencies are optional. This often happens for components that interact with many other components \*\*if available\*\* (that is, if they were included at compile time). This allows your component to interact with each other without for... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/faq.md | main | datadog-agent | [
0.017139974981546402,
-0.029266826808452606,
-0.03569379076361656,
-0.005490580573678017,
0.024143043905496597,
-0.028010286390781403,
0.019664011895656586,
0.07960030436515808,
-0.004937543533742428,
0.004361881874501705,
0.1147511675953865,
-0.0889691561460495,
0.007776699960231781,
0.04... | 0.045611 |
# Creating a Component This page explains how to create components in detail. This page uses the example of creating a compression component. This component compresses a payload before sending it to the Datadog backend. Since there are multiple ways to compress data, this component provides two implementations of the s... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/creating-components.md | main | datadog-agent | [
-0.10291176289319992,
0.05762676149606705,
-0.05173705145716667,
0.01521235890686512,
0.03019714541733265,
-0.04538177698850632,
0.013142210431396961,
0.053560756146907806,
0.0003407915064599365,
-0.019745618104934692,
0.02319849468767643,
0.06781528890132904,
0.08760926127433777,
0.035580... | 0.136487 |
// Decompress decompresses the input data. Decompress([]byte) ([]byte, error) } ``` /// All component interfaces must be called `Component`, so all imports have the form `.Component`. You can see that the interface only exposes the bare minimum. You should aim at having the smallest possible interface for your componen... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/creating-components.md | main | datadog-agent | [
-0.04312865436077118,
0.031854577362537384,
-0.051989130675792694,
-0.007519363891333342,
-0.03895020857453346,
-0.09012042731046677,
0.022370873019099236,
0.08747602999210358,
-0.04281610623002052,
-0.046166207641363144,
0.03881004452705383,
-0.06413409113883972,
0.009241088293492794,
0.0... | 0.190843 |
package zstdimpl import ( "fmt" compression "github.com/DataDog/datadog-agent/comp/compression/def" config "github.com/DataDog/datadog-agent/comp/core/config/def" log "github.com/DataDog/datadog-agent/comp/core/log/def" ) type Requires struct { Conf config.Component Log log.Component } type Provides struct { Comp compr... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/creating-components.md | main | datadog-agent | [
-0.07204610854387283,
0.06401437520980835,
-0.07597258687019348,
0.016197161749005318,
0.013554261066019535,
-0.03854019194841385,
0.01299177948385477,
0.08429894596338272,
-0.07641516625881195,
-0.037678979337215424,
0.014950470067560673,
0.0045594521798193455,
0.0470832996070385,
0.12880... | 0.035452 |
mock must implement the `Component` interface of the `def` folder but can expose more methods if needed. All mock constructors must take a `\*testing.T` as parameter. In the following example, your mock has no dependencies and returns the same string every time. /// tab | :octicons-file-code-16: comp/compression/mock/m... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/creating-components.md | main | datadog-agent | [
-0.09816064685583115,
0.05337544158101082,
-0.0701860785484314,
0.015607575885951519,
-0.047738101333379745,
-0.06937866657972336,
0.006821533665060997,
0.020783355459570885,
-0.07367287576198578,
-0.02807777374982834,
0.03873182833194733,
0.007032101508229971,
0.05597534403204918,
0.08956... | 0.00127 |
the robustness of the Agent. Documentation should include: \* Precise information on when each method may be called. Can methods be called concurrently? \* Precise information about data ownership of passed values and returned values. Users can assume that any mutable value returned by a component will not be modified ... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/creating-components.md | main | datadog-agent | [
-0.07017488777637482,
0.009405051358044147,
-0.045873165130615234,
0.03468434512615204,
-0.04808148369193077,
-0.034047916531562805,
-0.00869860127568245,
0.03407304733991623,
-0.0005341575015336275,
-0.011525842361152172,
0.035400569438934326,
0.0417151041328907,
0.0029448263812810183,
0.... | 0.079731 |
# Testing components Testing is an essential part of the software development life cycle. This page covers everything you need to know about testing components. One of the core benefits of using components is that each component isolates its internal logic behind its interface. Focus on asserting that each implementati... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/testing.md | main | datadog-agent | [
-0.04314294084906578,
0.03767034038901329,
-0.029375921934843063,
0.008608655072748661,
-0.005779542960226536,
-0.06108930706977844,
-0.03296681493520737,
-0.00798560120165348,
-0.03129059821367264,
-0.03224559500813484,
0.021316388621926308,
0.03797480836510658,
0.04366305097937584,
0.081... | 0.027402 |
`started` and `stopped` fields. To accomplish this, create a new lifecycle instance, create a `Require` struct instance, initialize the component, and validate that calling `Start` on the lifecycle instance calls the component hook and executes the logic. To create a lifecycle instance, use the helper function `compdef... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/testing.md | main | datadog-agent | [
-0.04321097210049629,
0.025142448022961617,
-0.08100199699401855,
-0.0013899299083277583,
0.0043181562796235085,
-0.008332004770636559,
-0.011436506174504757,
0.024670399725437164,
-0.055277761071920395,
-0.0037234548944979906,
0.09881536662578583,
0.003175963880494237,
-0.03628312051296234,... | 0.019379 |
# Overview of Fx The Agent uses [Fx](https://uber-go.github.io/fx) as its application framework. While the linked Fx documentation is thorough, it can be a bit difficult to get started with. This document describes how Fx is used within the Agent in a more approachable style. ## What Is It? Fx's core functionality is t... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/fx.md | main | datadog-agent | [
-0.012572191655635834,
-0.06728412955999374,
-0.013813816010951996,
0.04039676859974861,
-0.010572804138064384,
-0.0025619585067033768,
0.06608408689498901,
0.04243559390306473,
-0.0002963038859888911,
-0.09650155901908875,
-0.009508242830634117,
-0.023694800212979317,
0.011132501997053623,
... | 0.228309 |
an app that requirements are met, constructors are called, and so on. Tying the example above together, a very simple app might look like this: ```go someValue = "my password is hunter2" app := fx.New( fx.Provide(scrubber.NewScrubber), fx.Invoke(func(sc scrubber.Component) { fmt.Printf("scrubbed: %s", sc.ScrubString(so... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/fx.md | main | datadog-agent | [
-0.04188359156250954,
0.00022951366554480046,
-0.028527148067951202,
0.033653996884822845,
-0.0029705658089369535,
-0.02202407270669937,
0.06395933032035828,
0.09050553292036057,
-0.020907439291477203,
-0.0792144387960434,
0.034535761922597885,
-0.03294214606285095,
-0.014078417792916298,
... | 0.076116 |
by other components. For example: Here, two components add a `server.Endpoint` type to the `server` group (note the `group` label in the `fx.Out` struct). /// tab | :octicons-file-code-16: todolist/todolist.go ```go type provides struct { fx.Out Component Endpoint server.Endpoint `group:"server"` } ``` /// /// tab | :o... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/fx.md | main | datadog-agent | [
-0.010849940590560436,
-0.026360157877206802,
-0.04443397372961044,
0.032623469829559326,
-0.04816204309463501,
-0.00032511993777006865,
0.047518737614154816,
0.05676503852009773,
-0.0017063870327547193,
-0.07111657410860062,
0.0824805274605751,
-0.03757740929722786,
-0.09794875234365463,
... | 0.118643 |
# JMXFetch [JMXFetch](https://github.com/DataDog/jmxfetch/) is the component of the Agent which is responsible for collecting metrics from Java applications. For more details on JMXFetch or developer documentation, please visit the project documentation on the [JMXFetch GitHub repo](https://github.com/DataDog/jmxfetch/... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/jmxfetch.md | main | datadog-agent | [
-0.011837144382297993,
-0.0428827628493309,
-0.01894674263894558,
-0.06239213049411774,
-0.05054249241948128,
-0.004751835484057665,
-0.0029771672561764717,
0.04953771457076073,
-0.04498154670000076,
-0.014828343875706196,
0.012035145424306393,
-0.06933798640966415,
0.04241286590695381,
-0... | 0.092872 |
# Using components Using components within other components is covered on the [create components page](creating-components.md). Now let's explore how to use components in your binaries. One of the core idea behind component design is to be able to create new binaries for customers by aggregating components. ## the `cmd... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/using-components.md | main | datadog-agent | [
0.021239779889583588,
-0.043484367430210114,
-0.1321137398481369,
-0.06294714659452438,
-0.058529436588287354,
0.008502602577209473,
0.012048589065670967,
0.09319629520177841,
-0.08476891368627548,
-0.0166811291128397,
0.025678453966975212,
-0.07751475274562836,
0.06991611421108246,
0.0672... | 0.036088 |
migration to components is not finished, you might need to manually instruct Fx on how to use plain types. You will need to use `fx.Supply` for this. More details can be found [here](fx.md). But here is a quick example: ```go import ( logfx "github.com/DataDog/datadog-agent/comp/core/log/fx" log "github.com/DataDog/dat... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/using-components.md | main | datadog-agent | [
0.06926456093788147,
-0.02061537653207779,
-0.014934418722987175,
0.042376600205898285,
0.021572308614850044,
-0.015772512182593346,
0.06303854286670685,
0.10960092395544052,
-0.04147820174694061,
-0.06412400305271149,
0.03342683985829353,
-0.09207964688539505,
-0.025897154584527016,
0.112... | 0.039277 |
## Groups Fx [groups](https://pkg.go.dev/go.uber.org/fx#hdr-Value\_Groups) help you produce and group together values of the same type, even if these values are produced in different parts of the codebase. A component can add any type into a group; this group can then consumed by other components. In the following exam... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/common-patterns.md | main | datadog-agent | [
0.00429295701906085,
-0.019178932532668114,
-0.04630247876048088,
0.019877497106790543,
-0.05224796012043953,
0.0065953172743320465,
0.02076607011258602,
0.006201653275638819,
-0.019131185486912727,
-0.0798838660120964,
0.07505135983228683,
-0.04870534688234329,
-0.07339432090520859,
0.086... | 0.073777 |
# Flare The general idea is to register a callback within your component to be called each time a flare is created. This uses [Fx](../fx.md) groups under the hood, but helpers are there to abstract all the complexity. Once the callback is created, you will have to migrate the code related to your component from `pkg/fl... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/shared_features/flares.md | main | datadog-agent | [
-0.002036475343629718,
-0.04461400955915451,
-0.03668339550495148,
0.10936563462018967,
-0.017109358683228493,
-0.006639618426561356,
0.062017057090997696,
0.06847745180130005,
-0.025612320750951767,
-0.07349473237991333,
-0.03312690928578377,
-0.028181258589029312,
0.016168300062417984,
0... | 0.030351 |
# Status Components can register a status provider. When the status command is executed, we will populate the information displayed using all the status providers. ## Status Providers There are two types of status providers: - \*\*Header Providers:\*\* these providers are displayed at the top of the status output. This... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/shared_features/status.md | main | datadog-agent | [
-0.03712264820933342,
0.05325181037187576,
-0.06985507905483246,
0.020630070939660072,
0.007404405158013105,
-0.0053686415776610374,
-0.0020975524093955755,
0.007923892699182034,
0.007091890554875135,
-0.015684669837355614,
0.03929245471954346,
0.0036209982354193926,
0.04532844200730324,
-... | 0.162221 |
// Index renders the index func (c \*compressor) Section() int { return "Compression" } // JSON populates the status map func (c \*compressor) JSON(\_ bool, stats map[string]interface{}) error { c.populateStatus(stats) return nil } // Text renders the text output func (c \*compressor) Text(\_ bool, buffer io.Writer) er... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/components/shared_features/status.md | main | datadog-agent | [
-0.04673314094543457,
0.09319151937961578,
-0.05542870983481407,
0.07875489443540573,
0.007507710251957178,
0.04221361503005028,
-1.5787107088272023e-7,
0.07268340140581131,
0.005936304572969675,
-0.043164774775505066,
0.022860636934638023,
-0.03909284248948097,
-0.01960216462612152,
0.029... | 0.15435 |
# DogStatsD internals { loading=lazy role="img" } (click to enlarge) Information on DogStatsD, configuration and troubleshooting is available in the [Datadog documentation](https://docs.datadoghq.com/developers/dogstatsd/). ## Packet In DogStatsD, a Packet is a bytes ... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/architecture/dogstatsd/internals.md | main | datadog-agent | [
0.010290293954312801,
0.00597582571208477,
0.04821939393877983,
-0.013912854716181755,
-0.06695921719074249,
-0.05425552278757095,
-0.028564225882291794,
0.0029919296503067017,
-0.0024287074338644743,
0.019591862335801125,
0.01237077172845602,
-0.030339185148477554,
0.08590427041053772,
-0... | 0.02304 |
less than 2, the server spawns 2 workers. The Worker is using a system called StringInterner to not allocate memory every time a string is needed. Note that this StringInterner is caching a finite number of strings and when it is full it is emptied to start caching strings again. Its size is configurable with `dogstats... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/architecture/dogstatsd/internals.md | main | datadog-agent | [
-0.007343541830778122,
-0.03137599676847458,
-0.03970399871468544,
0.001220045960508287,
-0.13164012134075165,
-0.0554928332567215,
0.049194831401109695,
0.020737022161483765,
0.04697466641664505,
-0.0011008058208972216,
-0.025640344247221947,
-0.008561616763472557,
0.058133602142333984,
-... | 0.136423 |
# Config-provided hostname starting with `ip-` or `domu` ## Description of the issue In v6 and v7 Agents, if `hostname` is set in `datadog.yaml` (or through the `DD\_HOSTNAME` env var) and its value starts with `ip-` or `domu`, the hostname is not used in-app as the canonical hostname, even if it is a valid hostname. M... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/hostname/hostname_force_config_as_canonical.md | main | datadog-agent | [
0.019844401627779007,
-0.029794303700327873,
0.0333389975130558,
-0.05195463076233864,
-0.018159959465265274,
-0.09435427188873291,
-0.051780108362436295,
-0.030179576948285103,
-0.0037128368858247995,
0.018275167793035507,
0.048455558717250824,
-0.06044969707727432,
0.09504622966051102,
-... | -0.035002 |
# Using developer environments ----- Developer environments are preconfigured workspaces that provide everything required for contributing to the Agent code base, testing changes and building release artifacts. Usually, these are [images](../../reference/images/dev.md) that run using a container orchestrator like Docke... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/tutorials/dev/env.md | main | datadog-agent | [
0.014797406271100044,
-0.04236266762018204,
-0.015544882975518703,
-0.04343636333942413,
-0.0031546144746243954,
-0.11187397688627243,
-0.06934340298175812,
0.0017767079407349229,
-0.018793974071741104,
0.030447931960225105,
0.00439004972577095,
-0.10991846770048141,
0.053787946701049805,
... | 0.056022 |
``` dda env dev start --clone ``` You can also [configure][dda-config] `dda` to always [clone repositories](https://datadoghq.dev/datadog-agent-dev/reference/api/config/#dda.config.model.env.DevEnvConfig.clone\_repos) for developer environments with the following command. ``` dda config set env.dev.clone-repos true ```... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/tutorials/dev/env.md | main | datadog-agent | [
-0.0412462055683136,
-0.07447654753923416,
-0.011490068398416042,
-0.08079246431589127,
-0.014192519709467888,
-0.1162419468164444,
-0.049099214375019073,
-0.01044019777327776,
0.0048219203017652035,
0.025661982595920563,
0.04731785133481026,
-0.03225661814212799,
0.033886127173900604,
-0.... | -0.073728 |
in which to run the command is determined by the `-r`/`--repo` option, defaulting to the first defined [repository](#repository-selection). ## Building Let's [build](../../how-to/build/standalone.md) the default Agent by running the following command locally. ``` dda env dev run -- dda inv agent.build --build-exclude=s... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/tutorials/dev/env.md | main | datadog-agent | [
-0.0019483771175146103,
-0.03843310847878456,
-0.04533893242478371,
-0.12278635799884796,
0.025048760697245598,
-0.07613085210323334,
-0.06498824805021286,
0.013596760109066963,
-0.01593884453177452,
0.026345068588852882,
0.004544567782431841,
-0.07887684553861618,
0.008351875469088554,
-0... | -0.078877 |
# Lab environments ----- Lab environments are Kubernetes clusters for testing the Datadog Agent. The `dda lab` command group manages these environments. ## Supported providers | Provider | Category | Description | |----------|----------|-------------| | [Kind](kind.md) | Local | Kubernetes in Docker - lightweight local... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/tutorials/dev/lab/index.md | main | datadog-agent | [
0.008172090165317059,
-0.004461359232664108,
0.00845267716795206,
-0.0527503602206707,
0.022297710180282593,
-0.08637558668851852,
-0.029929688200354576,
-0.012845896184444427,
0.028838185593485832,
0.0009993785060942173,
0.013683948665857315,
-0.1283094584941864,
0.0116537781432271,
-0.01... | 0.102078 |
# Kind ----- [Kind](https://kind.sigs.k8s.io/) (Kubernetes in Docker) creates lightweight local Kubernetes clusters for development and testing. ## Prerequisites - Docker (or an equivalent container runtime) - [kind](https://kind.sigs.k8s.io/docs/user/quick-start/#installation) - [helm](https://helm.sh/docs/intro/insta... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/tutorials/dev/lab/kind.md | main | datadog-agent | [
0.019617248326539993,
0.030189095064997673,
0.04343513399362564,
-0.032745327800512314,
0.025641754269599915,
0.0017562549328431487,
-0.06369931995868683,
-0.013520372100174427,
0.0356949046254158,
0.033499911427497864,
0.002551580313593149,
-0.08198031038045883,
-0.007836021482944489,
-0.... | 0.081587 |
# Contributing to Datadog Agent First of all, thanks for contributing! This document provides some basic guidelines for contributing to this repository. To propose improvements, feel free to submit a PR. ## Submitting issues \* If you think you've found an issue, please search the [Agent Troubleshooting][agent-troubles... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/contributing.md | main | datadog-agent | [
-0.031968556344509125,
-0.03837957605719566,
0.026263132691383362,
0.061537228524684906,
0.0030580349266529083,
-0.05643587186932564,
-0.01173699926584959,
-0.03850962594151497,
-0.05115516111254692,
0.08443784713745117,
0.04361404478549957,
-0.0662229135632515,
0.046510353684425354,
0.005... | -0.004563 |
message generated by GitHub from: ``` Including new features \* Fix linter \* WIP \* Add test for x86 \* Fix licenses \* Cleanup headers ``` to: ``` Including new features This feature does this and that. Some tests are excluded on x86 because of ... ``` ### Pull request workflow The goals ordered by priority are: - Ma... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/contributing.md | main | datadog-agent | [
-0.06416016072034836,
0.005756231024861336,
-0.06387951225042343,
-0.005980235058814287,
0.0936015397310257,
-0.004610450007021427,
-0.05658961832523346,
0.02674836665391922,
0.013867277652025223,
0.07532741874456406,
0.05063726752996445,
-0.015470786951482296,
0.010221845470368862,
-0.053... | 0.006164 |
# Remove unused sections and fill the relevant ones. # Reno will create a new file in releasenotes/notes. # # Each section from every release note are combined when the CHANGELOG.rst is # rendered. So the text needs to be worded so that it does not depend on any # information only available in another section. This may... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/contributing.md | main | datadog-agent | [
-0.010509294457733631,
-0.031061559915542603,
0.026321085169911385,
-0.004401650279760361,
0.052879031747579575,
0.011287977918982506,
0.020723382011055946,
0.025994153693318367,
0.005374270491302013,
0.06587737053632736,
0.09213345497846603,
0.04299939051270485,
-0.011717492714524269,
0.0... | 0.023005 |
if there's no code changes in the Agent binary code. /// note | Important Use `qa/no-code-change` if your PR only changes tests or a module/package that does not end up in the Agent build. All of the following do not require QA: - Changing the CI configuration without impacting the Agent packaging. - Changing the docum... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/contributing.md | main | datadog-agent | [
0.0028676961082965136,
0.022446025162935257,
-0.01718960329890251,
-0.03490646556019783,
-0.04054008796811104,
-0.0015292977914214134,
-0.07090309262275696,
0.001680782181210816,
0.05223088711500168,
0.055995311588048935,
0.032501425594091415,
-0.08228736370801926,
0.014235471375286579,
-0... | 0.102513 |
# Writing developer docs ----- This site is built by [MkDocs](https://github.com/mkdocs/mkdocs) and uses the [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) theme. You can serve documentation locally with the `dda run docs serve` command. ## Organization The site structure is defined by the [`nav`](... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/docs.md | main | datadog-agent | [
-0.08098028600215912,
-0.046051591634750366,
0.04361686855554581,
0.008784420788288116,
0.007796338759362698,
-0.07253667712211609,
-0.09434454888105392,
-0.017500340938568115,
0.031293533742427826,
0.03757870942354202,
0.006255160551518202,
0.023756489157676697,
0.02260315790772438,
0.021... | 0.089854 |
# Component Registrations Components generally need to talk to one another! In simple cases, that occurs by method calls. But in many cases, a single component needs to communicate with a number of other components that all share some characteristics. For example, the `comp/core/health` component monitors the health of... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/registrations.md | main | datadog-agent | [
-0.022423261776566505,
-0.04522661119699478,
-0.04167822375893593,
0.0722530335187912,
-0.00834063533693552,
0.0293588787317276,
0.07784465700387955,
0.031272754073143005,
0.050305914133787155,
-0.07137301564216614,
0.02661035768687725,
-0.06816946715116501,
0.022237731143832207,
0.0517031... | 0.126816 |
# Defining Apps and Binaries ## Binaries Each binary is defined as a `main` package in the `cmd/` directory, such as `cmd/iot-agent`. This top-level package contains \_only\_ a simple `main` function (or often, one for Windows and one for \*nix) which performs any platform-specific initialization and then creates and e... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/defining-apps.md | main | datadog-agent | [
-0.0556374154984951,
0.055148251354694366,
-0.06950724124908447,
-0.02242937870323658,
-0.027818789705634117,
-0.07328113168478012,
-0.008899707347154617,
0.06336072087287903,
-0.042845677584409714,
-0.04043574631214142,
0.06707844883203506,
-0.04918784275650978,
0.025251004844903946,
0.04... | 0.114667 |
subcommands := sf(&globalParams) for \_, cmd := range subcommands { agentCmd.AddCommand(cmd) } } return cmd } ``` If the available subcommands depend on build flags, move the creation of the subcommand factories to the `subcommands/` package and create the slice there using source files with `//go:build` directives. Yo... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/defining-apps.md | main | datadog-agent | [
-0.05234881490468979,
-0.012777147814631462,
-0.03536014258861542,
-0.052407167851924896,
-0.062407586723566055,
-0.008267959579825401,
-0.011191180907189846,
0.05764508992433548,
-0.111172154545784,
-0.047988034784793854,
0.08608389645814896,
-0.11880387365818024,
0.004586178343743086,
0.... | 0.075172 |
# Defining Component Bundles A bundle is defined in a dedicated package named `comp/`. The package must have the following defined in `bundle.go`: \* Extensive package-level documentation. This should define: \* The purpose of the bundle \* What components are and are not included in the bundle. Components might be omi... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/defining-bundles.md | main | datadog-agent | [
-0.06754706799983978,
0.0037190087605267763,
0.008832432329654694,
0.004173486027866602,
0.06121546030044556,
0.07514358311891556,
0.055386755615472794,
0.10386944562196732,
-0.05991964787244797,
-0.04519588127732277,
0.09322233498096466,
-0.028511233627796173,
-0.04025435447692871,
0.0941... | 0.067606 |
# Using Components and Bundles ## Component Dependencies Component dependencies are automatically determined from the arguments to a component constructor. Most components have a few dependencies, and use a struct named `dependencies` to represent them: ```go type dependencies struct { fx.In Lc fx.Lifecycle Params inte... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/using-components.md | main | datadog-agent | [
-0.04296743869781494,
-0.06597072631120682,
0.03356076404452324,
0.021994706243276596,
0.06349547207355499,
0.0012276505585759878,
0.03713182359933853,
0.0764424204826355,
-0.05412803217768669,
-0.06872356683015823,
0.05723642557859421,
-0.049387138336896896,
-0.05693061277270317,
0.121469... | 0.019253 |
# Purpose of component guidelines This section describes the mechanics of implementing [apps](defining-apps.md), [components](../../components/creating-components.md), and [bundles](defining-bundles.md). The guidelines are quite prescriptive, with the intent of making all components "look the same". This reduces cognit... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/purpose.md | main | datadog-agent | [
-0.047803279012441635,
-0.013662781566381454,
-0.018933724611997604,
-0.04822457581758499,
0.04674829915165901,
0.02951015718281269,
-0.016920188441872597,
0.0516328364610672,
-0.03607788309454918,
-0.0069186752662062645,
0.0332198441028595,
0.021303698420524597,
-0.0013675781665369868,
0.... | 0.053463 |
# Component Subscriptions Subscriptions are a common form of registration, and have support in the `pkg/util/subscriptions` package. In defining subscriptions, the component that transmits messages is the \_collecting\_ component, and the processes receiving components are the \_providing\_ components. These are matche... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/deprecated-components-documentation/subscriptions.md | main | datadog-agent | [
-0.051814403384923935,
-0.06232200562953949,
-0.043536730110645294,
0.0029598192777484655,
-0.012664168141782284,
-0.004562919028103352,
0.12042930722236633,
0.010035746730864048,
0.011877444572746754,
-0.04433249309659004,
0.03930698335170746,
-0.04580329358577728,
0.055272288620471954,
0... | 0.109134 |
# Go guidelines ----- ## Imports The imports defined in the `imports ( ... )` block of each Go file should be separated into the following sections, in order. 1. Standard library packages (e.g. `fmt`, `net/http`) 1. External packages (e.g. `github.com/stretchr/testify/assert`, `github.com/DataDog/datadog-agent/pkg/util... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/languages/go.md | main | datadog-agent | [
-0.036104392260313034,
0.03478075563907623,
-0.05573585629463196,
-0.03197559714317322,
0.02957397885620594,
-0.05266847088932991,
-0.0407794751226902,
0.04909910634160042,
-0.0363425612449646,
-0.002432461129501462,
0.08070392906665802,
-0.022508325055241585,
0.037902530282735825,
0.11917... | 0.007345 |
\_very\_ low-level concept and full of subtle gotchas and dramatic performance differences across platforms. If you can use something higher-level, such as something from the standard library's `sync` [package](https://pkg.go.dev/sync), prefer to do so. Otherwise, if you are in search of performance, be sure to benchma... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/languages/go.md | main | datadog-agent | [
-0.028376346454024315,
0.02635311521589756,
-0.06267900764942169,
-0.020298775285482407,
0.04539470374584198,
-0.039146676659584045,
-0.060515161603689194,
-0.029467584565281868,
-0.005752283148467541,
-0.07871057093143463,
0.015120130032300949,
-0.049943361431360245,
-0.02618146687746048,
... | 0.047699 |
major source of flakes. If you find yourself thinking something like "the ticker should run three times in 500ms", you will be disappointed at how often that is not true in CI. Even if that test is not flaky, it will take at least 500ms to run. Summing such delays over thousands of tests means \_very\_ long test runs a... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/languages/go.md | main | datadog-agent | [
-0.07175754755735397,
-0.010650021024048328,
-0.06903818249702454,
0.09744445979595184,
0.035569626837968826,
-0.11363758891820908,
-0.04184365272521973,
0.017242703586816788,
0.054914526641368866,
-0.021330708637833595,
-0.0284590907394886,
-0.044448766857385635,
-0.04427694156765938,
-0.... | 0.073773 |
# Test Categories The Datadog Agent employs a comprehensive testing strategy with four distinct categories of tests, each serving a specific purpose in ensuring code quality, functionality, and reliability. This document serves as both a reference guide and decision-making framework for choosing the appropriate test ty... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/testing/test-categories.md | main | datadog-agent | [
-0.048308115452528,
-0.020032469183206558,
-0.014715082012116909,
0.03197779878973961,
-0.029515540227293968,
-0.07427555322647095,
-0.05703141540288925,
-0.03079765848815441,
-0.023881662636995316,
-0.00585223687812686,
0.03227870911359787,
-0.06236565113067627,
0.05426766723394394,
-0.00... | 0.108088 |
per test). - \*\*Environment Specific\*\*: May require specific OS features or permissions. \*\*Examples\*\*: ```go // Testing DogStatsD metric forwarding pipeline func TestDogStatsDMetricPipeline(t \*testing.T) { // Start Agent with test configuration agent := startTestAgent(t, &Config{ DogStatsDPort: 8125, APIKey: "t... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/testing/test-categories.md | main | datadog-agent | [
-0.02891857922077179,
-0.022040968760848045,
-0.0544680692255497,
-0.00198597670532763,
-0.07941261678934097,
-0.08137329667806625,
-0.04356959089636803,
0.047568075358867645,
-0.03166358545422554,
-0.0038396483287215233,
0.028164999559521675,
-0.07638943940401077,
-0.010541257448494434,
0... | 0.068861 |
integration tests for external dependencies, use system tests for component interactions, and implement E2E tests for critical user workflows. | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/testing/test-categories.md | main | datadog-agent | [
-0.052262358367443085,
-0.046141061931848526,
0.019318340346217155,
-0.037009116262197495,
0.042911045253276825,
-0.06991855055093765,
-0.013774704188108444,
0.09770875424146652,
-0.03523281216621399,
-0.026871105656027794,
-0.01513337530195713,
-0.09506213665008545,
-0.011332170106470585,
... | 0.2314 |
# Logging ## Writing a good log message In general, there are a few rules and a few suggestions to follow when it comes to writing good log messages: - Messages must be written in English, preferably in American English. - Use proper spelling and grammar when possible. Because not everyone is a native English speaker, ... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/guidelines/conventions/logging.md | main | datadog-agent | [
0.0015897245611995459,
0.020294204354286194,
0.07138456404209137,
-0.006224885117262602,
0.0794091448187828,
-0.015955986455082893,
0.10356465727090836,
0.06457474082708359,
0.02365932986140251,
0.0308259017765522,
-0.020418770611286163,
-0.03240523859858513,
-0.009413029998540878,
0.03460... | 0.131892 |
# Developer environment reference ----- The developer environments are [container images](https://github.com/DataDog/datadog-agent-buildimages/tree/main/dev-envs) that use the [builders](builders.md) as a base image. These images are only intended for use by the [`dda env dev`](https://datadoghq.dev/datadog-agent-dev/r... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/reference/images/dev.md | main | datadog-agent | [
0.0022504047956317663,
0.006239218171685934,
-0.011753044091165066,
-0.0371648408472538,
0.07745110988616943,
-0.09812982380390167,
-0.11312989890575409,
0.009833264164626598,
0.009083383716642857,
0.03719695284962654,
0.022283397614955902,
-0.07528970390558243,
0.05974447727203369,
0.0032... | 0.048426 |
# Build image reference ----- All non-macOS release artifacts are produced within [container images](https://github.com/DataDog/datadog-agent-buildimages) that are hosted on the [Datadog Docker Hub](https://hub.docker.com/u/datadog). /// note These images are not meant to be used directly outside of CI scenarios. Inste... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/reference/images/builders.md | main | datadog-agent | [
-0.03995808959007263,
0.0357833206653595,
-0.010592099279165268,
-0.04046012461185455,
0.05703369155526161,
-0.1311667412519455,
-0.09759027510881424,
0.004033874254673719,
-0.0020980502013117075,
0.02890358492732048,
0.056533847004175186,
-0.09148155897855759,
0.07815572619438171,
-0.0107... | 0.091269 |
# Agent components ## Agent binaries The "Agent" is not distributed as a single binary. Instead, running an Agent on a given host will usually involve multiple processes communicating with each other, spawned from different binaries[^1]. These binaries have a good amount of code shared between them, but are all buildab... | https://github.com/DataDog/datadog-agent/blob/main//docs/public/reference/builds/components.md | main | datadog-agent | [
0.020114870741963387,
-0.036606110632419586,
-0.08057501167058945,
-0.05491853877902031,
0.04426971822977066,
-0.04092932865023613,
-0.04125590994954109,
0.0034511133562773466,
-0.04302859678864479,
-0.009202945046126842,
-0.022877583280205727,
-0.02463672123849392,
0.06587023288011551,
-0... | 0.122404 |
# Endpoints exposed by the Agent The core Agent exposes a variety of HTTP and GRPC endpoints that can be organized into two groups: 1. \*\*Control\*\*: These endpoints are used to send commands that can control and inspect the state of the running Agent. 2. \*\*Inter-process communication\*\*: These endpoints are used ... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/agent_api.md | main | datadog-agent | [
-0.030623361468315125,
-0.0018140854081138968,
-0.12285076826810837,
-0.06373530626296997,
-0.017463453114032745,
-0.07427965849637985,
-0.013645654544234276,
0.0025590267032384872,
0.035845495760440826,
0.004342244006693363,
0.03448430448770523,
-0.022248564288020134,
0.0016365820774808526,... | 0.240548 |
# How to add a `replace` directive to `go.mod` `go.mod` files allow different types of directives including `require` or `replace`. This document describes how and when to add a `replace` directive to our go.mod files. ## Why we should avoid `replace` directives `replace` directives replace a given dependency code on t... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/gomodreplace.md | main | datadog-agent | [
-0.06218688189983368,
0.04022234305739403,
0.06765664368867874,
-0.022366277873516083,
0.07408348470926285,
0.005505289416760206,
-0.02975550852715969,
-0.02910716086626053,
0.001661518239416182,
-0.02593863382935524,
0.10767783224582672,
0.06408359110355377,
-0.01878545805811882,
0.064615... | 0.019789 |
# Developer Guide This guide will help you to develop and contribute code to the project. ## Table of Content \* [Custom checks developer guide](checks/README.md) \* [Python builtin modules](checks/builtins) \* [Agent IPC API](agent\_api.md) \* [How to build the Agent packages][agent-omnibus] \* [Testing guide][testing... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/README.md | main | datadog-agent | [
0.01312316581606865,
-0.0021671191789209843,
-0.13440315425395966,
-0.052104610949754715,
0.0122047895565629,
-0.01854565739631653,
-0.0015276143094524741,
0.043130602687597275,
-0.09609148651361465,
0.038331419229507446,
0.029964588582515717,
-0.011162495240569115,
0.02459673024713993,
0.... | 0.134423 |
# Agent Configuration This doc describes how to define new configuration parameters for the Agent. 1. Define your config. 2. Add it to the config template (optional). 3. Use your config in your code. 4. Request a review from the Agent configuration team (team/agent-configuration) If you have any questions, head over to... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/config.md | main | datadog-agent | [
0.007184459362179041,
-0.021839747205376625,
-0.08813302218914032,
0.034702084958553314,
-0.02097424678504467,
-0.027705175802111626,
0.01673518307507038,
0.058654990047216415,
-0.12018077075481415,
-0.026192782446742058,
0.06120800971984863,
-0.049417294561862946,
0.10760537534952164,
-0.... | 0.06548 |
# Legal You must sign [our CLA](https://gist.github.com/bits-bot/55bdc97a4fdad52d97feb4d6c3d1d618) before we can accept your contributions. The first time you submit a PR, a bot will walk you through the automated process. On subsequent contributions you will not be prompted unless the content of the agreement has chan... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/legal.md | main | datadog-agent | [
-0.08095084130764008,
0.03678271174430847,
-0.012566815130412579,
-0.08344880491495132,
0.030113089829683304,
0.007287835236638784,
0.040576234459877014,
-0.009894328191876411,
0.025004666298627853,
0.0418967679142952,
0.05665934830904007,
0.01290240976959467,
0.028348905965685844,
-0.0315... | -0.024741 |
# Development Caveats This document provides a list of known development caveats ## Windows ### COM Caveats The COM concurrency model may be set in different ways, it also has to be called for every thread that might indeed interact with the COM library. Furthermore, once a concurrency model is set for a thread, it can... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/caveats.md | main | datadog-agent | [
-0.0713273361325264,
-0.11025971919298172,
-0.04071146622300148,
-0.018047934398055077,
-0.051180846989154816,
-0.0751228779554367,
-0.008096674457192421,
-0.004988444037735462,
-0.0043702214024960995,
-0.029243309050798416,
-0.010030907578766346,
0.013218524865806103,
0.02747403457760811,
... | 0.100005 |
# Custom checks developer guide For more informations about what a Custom check is and whether they are a good fit for your use case, please [refer to the official documentation][custom-checks]. ## JMX-based checks JMX-based checks are executed by a component of the Agent called `jmxfetch`. See the [JMXFetch repo](http... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/README.md | main | datadog-agent | [
0.009364168159663677,
-0.014978800900280476,
-0.034806154668331146,
-0.04759921133518219,
0.0027349311858415604,
-0.0728241503238678,
0.04894659295678139,
-0.0006225417600944638,
-0.04937856271862984,
-0.010599992237985134,
0.053711216896772385,
0.03606010600924492,
0.033000629395246506,
-... | 0.091367 |
- [aggregator](builtins/aggregator.md) - [containers](builtins/containers.md) - [datadog\_agent](builtins/datadog\_agent.md) - [kubeutil](builtins/kubeutil.md) - [tagger](builtins/tagger.md) - [util](builtins/util.md) [custom-checks]: https://docs.datadoghq.com/developers/write\_agent\_check/?tab=agentv6 [collector]: /... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/README.md | main | datadog-agent | [
0.007451518438756466,
0.04231390729546547,
-0.04018425568938255,
-0.020816365256905556,
-0.0260848980396986,
-0.07508613914251328,
0.00535196578130126,
-0.026954885572195053,
0.02643546275794506,
0.035699695348739624,
0.04961738362908363,
-0.11765847355127335,
0.07025350630283356,
-0.03121... | 0.075099 |
have dependencies, specifically on the open source `redisdb` package. In this case, we need to install the `deps` explicitly. ``` python3 -m pip install --user './redisdb[deps]' ``` That's it! Your local build should now have the correct packages to be able to run the `redisdb` check. (You may need to set the correct `... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/README.md | main | datadog-agent | [
-0.018772870302200317,
-0.07345838099718094,
-0.03658114746212959,
0.004803359974175692,
-0.02284889481961727,
-0.04419771581888199,
-0.02215658128261566,
0.01822051964700222,
-0.02288842387497425,
0.021181782707571983,
-0.016958603635430336,
-0.03187417611479759,
0.03926127031445503,
0.03... | -0.048996 |
# \_util > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. The module exposes low level functions to run proc... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/_util.md | main | datadog-agent | [
-0.04993937164545059,
0.03739093616604805,
-0.057432085275650024,
0.009314913302659988,
-0.06270824372768402,
-0.11040029674768448,
0.04174398258328438,
0.03755994513630867,
-0.018341058865189552,
-0.038724515587091446,
0.021923167631030083,
-0.05774400755763054,
0.0607944056391716,
0.0277... | 0.055653 |
# tagger > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. The module exposes [tagger](/comp/core/tagger) fun... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/tagger.md | main | datadog-agent | [
-0.03631575405597687,
0.06769201159477234,
-0.09884117543697357,
-0.0013564719120040536,
-0.021509161219000816,
-0.14674736559391022,
0.060899291187524796,
0.06438235938549042,
-0.06662862747907639,
-0.02228112518787384,
0.05409843474626541,
-0.05242098122835159,
0.06619179993867874,
0.016... | 0.064013 |
# datadog\_agent > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. The `datadog\_agent` module exposes featur... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/datadog_agent.md | main | datadog-agent | [
0.0063306912779808044,
0.05510137602686882,
-0.08052442967891693,
-0.022836588323116302,
-0.010505023412406445,
-0.06611624360084534,
0.021182077005505562,
-0.012817731127142906,
-0.0552946999669075,
-0.03262350335717201,
0.08210481703281403,
-0.001286866725422442,
0.04643307626247406,
0.0... | 0.032389 |
# kubeutil > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. This modules provides specific functionalities t... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/kubeutil.md | main | datadog-agent | [
0.009173281490802765,
0.013555056415498257,
-0.060499805957078934,
0.01275703962892294,
-0.08158863335847855,
-0.04073319211602211,
0.03493760526180267,
-0.004242576193064451,
0.06408520042896271,
-0.006855455227196217,
0.029465192928910255,
-0.1188431903719902,
0.02783023752272129,
-0.045... | 0.139601 |
# containers > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. The module exposes functionalities used to col... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/containers.md | main | datadog-agent | [
0.005353084299713373,
0.12176565825939178,
-0.025371219962835312,
0.014658763073384762,
0.006038764026015997,
-0.1150558739900589,
0.07748515158891678,
-0.010565138421952724,
0.0009334989590570331,
-0.06627749651670456,
0.04936109110713005,
-0.04983999580144882,
0.1073707565665245,
0.01717... | 0.051071 |
# util > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. This module exists only to provide backward compatib... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/util.md | main | datadog-agent | [
-0.04208947718143463,
0.07097289711236954,
-0.05289207026362419,
0.003552235895767808,
-0.028076931834220886,
-0.10314134508371353,
0.020375173538923264,
-0.010646829381585121,
-0.0358419269323349,
0.012691291980445385,
0.04160688817501068,
-0.03730642795562744,
0.08316710591316223,
-0.003... | 0.029249 |
# aggregator > \*\*This module is intended for internal use and should never be imported directly.\*\* > Checks should use the methods exposed by the `AgentCheck` class instead, see > [dedicated docs](https://datadoghq.dev/integrations-core/base/about/) for > more details. The `aggregator` module allows a Python check ... | https://github.com/DataDog/datadog-agent/blob/main//docs/dev/checks/builtins/aggregator.md | main | datadog-agent | [
-0.06003102287650108,
-0.023238634690642357,
-0.08139725774526596,
0.04336385056376457,
-0.04464327543973923,
-0.06165837496519089,
0.03125523775815964,
0.0107381297275424,
-0.01191606093198061,
-0.0036401518154889345,
0.05053750425577164,
-0.04619915783405304,
0.06218108534812927,
-0.0017... | 0.083311 |
# Buffer > Stability: 2 - Stable `Buffer` objects are used to represent a fixed-length sequence of bytes. Many Node.js APIs support `Buffer`s. The `Buffer` class is a subclass of JavaScript's {Uint8Array} class and extends it with methods that cover additional use cases. Node.js APIs accept plain {Uint8Array}s wherever... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
-0.010107012465596199,
0.004429360385984182,
-0.01048326212912798,
0.021127475425601006,
-0.036448657512664795,
-0.05708445608615875,
-0.004163931589573622,
0.05271921679377556,
-0.01529567688703537,
-0.06869561970233917,
-0.10029745101928711,
0.09426730126142502,
-0.02427849732339382,
-0.... | 0.10969 |
Node.js buffers accept all case variations of encoding strings that they receive. For example, UTF-8 can be specified as `'utf8'`, `'UTF8'`, or `'uTf8'`. The character encodings currently supported by Node.js are the following: \* `'utf8'` (alias: `'utf-8'`): Multi-byte encoded Unicode characters. Many web pages and ot... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.021966004744172096,
-0.019273903220891953,
0.06181001290678978,
-0.021022073924541473,
-0.024043168872594833,
-0.028155183419585228,
-0.01884309947490692,
0.00017445118282921612,
0.0929156020283699,
-0.019759994000196457,
-0.04405747354030609,
0.021591635420918465,
-0.015928518027067184,
... | 0.046107 |
represented. ``` ```cjs const { Buffer } = require('node:buffer'); Buffer.from('1ag123', 'hex'); // Prints , data truncated when first non-hexadecimal value // ('g') encountered. Buffer.from('1a7', 'hex'); // Prints , data truncated when data ends in single digit ('7'). Buffer.from('1634', 'hex'); // Prints , all data ... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
-0.02084585465490818,
0.0653528943657875,
-0.015306835062801838,
-0.031504660844802856,
-0.06841886788606644,
-0.07235626131296158,
0.037688959389925,
0.02893863245844841,
0.023841246962547302,
-0.06987906992435455,
0.0017881046514958143,
0.014708301983773708,
-0.02716720849275589,
-0.0087... | 0.066903 |
use only a portion of the underlying {ArrayBuffer} by passing in `byteOffset` and `length` parameters. ```mjs import { Buffer } from 'node:buffer'; const arr = new Uint16Array(20); const buf = Buffer.from(arr.buffer, 0, 16); console.log(buf.length); // Prints: 16 ``` ```cjs const { Buffer } = require('node:buffer'); co... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.06030559912323952,
0.0683722198009491,
-0.016797954216599464,
-0.03311898559331894,
-0.06842853128910065,
-0.04230180010199547,
0.05462424084544182,
0.03455192595720291,
-0.03901979327201843,
-0.07371741533279419,
-0.10318928956985474,
0.028555572032928467,
-0.046733032912015915,
-0.0094... | 0.092723 |
content of the `Blob` to be read. ### `blob.text()` \* Returns: {Promise} Returns a promise that fulfills with the contents of the `Blob` decoded as a UTF-8 string. ### `blob.type` \* Type: {string} The content-type of the `Blob`. ### `Blob` objects and `MessageChannel` Once a {Blob} object is created, it can be sent v... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.014500211924314499,
-0.0036303275264799595,
0.02631775662302971,
0.08376660943031311,
-0.0583152137696743,
-0.07914996147155762,
0.08393298089504242,
0.012861935421824455,
0.06564458459615707,
-0.062460023909807205,
-0.020892580971121788,
0.04136761650443077,
0.02068883739411831,
0.02505... | 0.140145 |
are unknown and \_may contain sensitive data\_. Use [`Buffer.alloc()`][] instead to initialize `Buffer` instances with zeroes. ```mjs import { Buffer } from 'node:buffer'; const buf = Buffer.allocUnsafe(10); console.log(buf); // Prints (contents may vary): buf.fill(0); console.log(buf); // Prints: ``` ```cjs const { Bu... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.026723530143499374,
0.019543901085853577,
-0.03563183173537254,
0.003562150988727808,
-0.01346930954605341,
-0.041682980954647064,
0.05756397172808647,
0.08423744887113571,
0.005462929606437683,
-0.05808302387595177,
-0.022560305893421173,
-0.008981761522591114,
-0.0324152335524559,
-0.0... | 0.074516 |
encoded using `encoding`. This is not the same as [`String.prototype.length`][], which does not account for the encoding that is used to convert the string into bytes. For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input. For strings that contain non-base64/hex-encoded data (e.g. whitespace), t... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.049376532435417175,
0.0769246518611908,
0.007810190785676241,
0.008548939600586891,
-0.08523166924715042,
-0.03727421909570694,
-0.004728957545012236,
0.08401670306921005,
0.031000124290585518,
-0.02256002463400364,
-0.0803389623761177,
0.019175661727786064,
0.03955766558647156,
-0.03083... | 0.019752 |
`0`. \* `length` {integer} The number of elements from `view` to copy. \*\*Default:\*\* `view.length - offset`. \* Returns: {Buffer} Copies the underlying memory of `view` into a new `Buffer`. ```js const u16 = new Uint16Array([0, 0xffff]); const buf = Buffer.copyBytesFrom(u16, 1, 1); u16[1] = 0; console.log(buf.length... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.06065395474433899,
0.00596600491553545,
-0.051732804626226425,
-0.018499961122870445,
-0.03428180143237114,
-0.04524854198098183,
0.06830793619155884,
-0.0032734437845647335,
0.004197893664240837,
-0.10526213049888611,
-0.04009498655796051,
-0.00846476387232542,
-0.0025867584627121687,
-... | 0.146843 |
{ Buffer } from 'node:buffer'; const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements console.log(arrA.buffer === arrB.buffer); // true const buf = Buffer.from(arrB.buffer); console.log(buf); // Prints: ``` ```cjs const { Buffer } = require('n... | https://github.com/nodejs/node/blob/main//doc/api/buffer.md | main | nodejs | [
0.061266329139471054,
0.04013781622052193,
-0.0631774365901947,
0.007035302463918924,
-0.06080729886889458,
-0.03303470462560654,
0.06594233959913254,
-0.03772127628326416,
-0.011171430349349976,
-0.05305672436952591,
-0.07637733221054077,
0.0024232270661741495,
-0.059117406606674194,
-0.0... | 0.053317 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.