https://github.com/DataDog/dd-agent/blob/master/datadog.conf.example#L411-L421

Potentially large topic. Maybe gather lots of resources from the web. Maybe throw some allspaw and codahale talks

centos5:

/etc/init.d/datadog-agent

centos6:

/etc/dd-agent/supervisor.conf

deb/ubuntu:

/etc/supervisor/conf.d/ddagent.conf

The code is already there, and it's a pretty simple API. So we should document it.

*nix: /etc/dd-agent/datadog.conf
osx (source install): ~/.datadog-agent/agent/datadog.conf
Windows 2008: C:\ProgramData\Datadog
Windows (other): C:\Documents and Settings\All Users\Application Data\Datadog\

Right now when you go to docs.datadoghq.com, you need to click on another link to see what the site is about. I like how Sinatra does it where there's a minimal hello world example, then links for more indepth docs.

So that is documented somewhere.

Similar to Datadog's release event with the diff link

• how many points you can send per second
• performance characteristics, etc.

http://help.datadoghq.com/kb/graphs-dashboards/graph-primer

Run the agent's shell by navigating to C:\Program Files (x86)\Datadog\Datadog Agent and running shell.exe. From here you can run parts of the agent.

To test IIS:

ipaddress = 'blah'
import wmi
w = wmi.WMI(ipaddress, user=None, password=None)
wmi_cls = w.Win32_PerfFormattedData_W3SVC_WebService(name="_Total")[0]
print wmi_cls.BytesSentPerSec

Already docs on this, just needs to be part of the guide's index

For example, the differences between functions and aggregators:

Yes, min, max and avg aren't functions per se, they're aggregators. We haven't documented our model as well as we should, but we consider functions as transforms of a single metric series, whereas aggregators combine many metric series's across tags. For example, if we had a metric called foo with values:

host:a = 1,1,4,1,1
host:b = 2,2,0,2,2

Using the min aggregator like min:foo{*} would turn the two series into a single series:

1,1,0,1,1

If we added a min function like min(foo{host:a}), we would get just a single value of 1.

If we had min(foo{*}), we'd still need an aggregator, in this case avg is assumed, so that would be:

avg:foo{} = 1.5, 1.5, 2, 1.5, 1.5
min(avg:foo{}) = 1.5

If we wanted the hosts in tact, we would say min(foo{*} by {host}), then we'd apply the function to each series:

min(host:a) = 1
min(host:b) = 0

ie, how the aggregation works, how many points you should see etc

• @ mention syntax in events
• metric alerts

Metric names must start with a letter, and after that may contain ascii alphanumerics, underscore and periods. Other characters will get converted to underscores. There is no max length

Explain throughput, latency, error rate.

• size of the queue
• queue processing throughput
• length of time spent in queue
• error rate in processing

Other API endpoints require the host_id to be passed, yet there is no clear way to get these IDs without clicking around on the infrastructure overview.

This will drive API changes, but it's probably a good place to start.

Need to set dd_url in datadog.conf to a host in your data center that is allowed to connect to datadoghq.com directly, then update the file that runs the agent (see #54) to remove --use-local-forwarder so that it uses the dd_url value instead of localhost.

currently we allow the embedding of specific graphs on other sites
if you open the editor on the graph you want to share, and click on the Share tab
you can generate an html snippet you can put on other sites

They point to the old api.datadoghq.com site.

Not properly configuring your fqdn will cause unwated aliasing.

Metric names must start with a letter, and after that may contain alphanumerics, underscores, minuses, colons, periods and slashes. Other characters will get converted to underscores. Tags can be up to 200 characters long and support unicode.

• dogstatsd
• logging + agent log parser

• Set up tagging
• Graph editor

I like the way the sidebar stays visible for the guides. It would be great it the same was true of the API Reference bar so I could switch languages and jump around without scrolling back to the top.

A recent addition to the agent, dogstreams can use classes in addition to functions to parse logs. Useful when needing stateful parsing with initialization.

It's primarily a cloud service, but in order to collect data on your servers, there is an agent you'll need to install.

In terms of metric naming, we differ a little with Graphite in that a metric query is defined by a metric name and a scope, where a scope is one or more tags. To translate:

<application>.requests.<HTTP Method>.<Handler Class>.<Handler Method>.mean_90

into Datadog, we'd probably say:

<application>.requests.mean_90{http_method:<HTTP Method>, handler_class:<Handler Class>, handler_method:<Handler Method>}

Where <application>.requests.mean_90 is the metric name, and http_method:, handler_class:, handler_method: are tags, so a concrete example might look like:

sync.requests.mean_90{http_method:GET, handler_class:ItemHandler, handler_method:list}

To do aggregation, we can specify an aggregator as part of the metric query:

avg:sync.requests.mean_90{http_method:GET, handler_class:ItemHandler, handler_method:list}

This will graph a single series that's the average of that metric across the intersection of those tags. We support avg, sum, min, max aggregators. If you wanted to see all the possible series for a given tag facet, you can say:

avg:sync.requests.mean_90{handler_class:ItemHandler, handler_method:list} by {http_method}

Which would graph stacked area series for each http_method value like GET, POST, etc.

No mobile, but you can reply to emails and they'll become comments

Need to actually implement this

If you don't know any better, it seems like a crashing bug on our end

• various event inputs
• aggregation key

Covering simple and multi-alerts:

• query syntax
• notify_no_data
• auto-resolution

Need a clear example with calling increment() multiple times during a flush interval and not calling it all. Also explain how it is different from distributed counters (i.e. there is no state kept between calls if data get flushed).

• links to "guide to metrics"
• links to "guide to graphs"
• etc

see stripe's docs for a great example.

On linux, < 3.4.0:

cd /usr/share/datadog/agent && python -c 'import config; print config.get_version()'

Linux, >= 3.4.0:

/etc/init.d/datadog-agent status

Windows: ...

Use system.disk.in_use, collected by the agent.

• graph editor search value
• stream on dash

In Counters:

Counters

Counters track how many times something _happened happened_, like the number of database requests or page views.

dog.increment('database.query.count')
dog.increment('page_view.count', 10)