# Java

Contents

* [Java](broken://pages/1jTcOzP3JGZ3DkyCL2pr)
  * [Interesting Java Metrics Libraries](#interesting-java-metrics-libraries)
  * [Java DNS Behaviour](#java-dns-behaviour)
  * [Sending a metric via TCP](#sending-a-metric-via-tcp)
  * [Sending a metric via UDP](#sending-a-metric-via-udp)
  * [Sending a metric via HTTP POST](#sending-a-metric-via-http-post)
  * [Google App Engine HTTP Post](#google-app-engine-http-post)

### [Interesting Java Metrics Libraries](#interesting-java-metrics-libraries)

* **Coda Hale’s metrics library**

  <http://metrics.dropwizard.io/> - Developed by Yammer to instrument their JVM-based backend services, it’s a really comprehensive Java metrics library and works well with Hosted Graphite.
* **Metrics-StatsD for Coda Hale’s metrics library**

### [Java DNS Behaviour](#java-dns-behaviour)

Java’s default JVM behaviour includes an optimisation/attempt to prevent DNS cache poisoning whereby it will read DNS entries for a service and then cache them forever. **This is something that will result in problems with Hosted Graphite**.

To service our hundreds of customers we run a **lot** of different machines and we swap machines in and out all the time. This means that if you have cached the DNS entry for a machine that no longer exists, you’re going to drop a lot of data.

To prevent this, you can set the JVM cache behaviour to only cache entries for 60 seconds:

```
java.security.Security.setProperty("networkaddress.cache.ttl" , "60");
```

### [Sending a metric via TCP](#sending-a-metric-via-tcp)

```java
import java.io.DataOutputStream;
import java.net.Socket;

...
Socket conn          = new Socket("YOUR-UID.carbon.hostedgraphite.com", 2003);
DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
dos.writeBytes("YOUR-API-KEY.foo.java-tcp 1.2\n");
conn.close();
```

### [Sending a metric via UDP](#sending-a-metric-via-udp)

```java
import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetAddress;

...
DatagramSocket sock   = new DatagramSocket();
InetAddress addr      = InetAddress.getByName("YOUR-UID.carbon.hostedgraphite.com");
byte[] message        = "YOUR-API-KEY.foo.java-udp 1.2\n".getBytes();
DatagramPacket packet = new DatagramPacket(message, message.length, addr, 2003);
sock.send(packet);
sock.close();
```

### [Sending a metric via HTTP POST](#sending-a-metric-via-http-post)

```java
import java.util.Base64;
import javax.net.ssl.HttpsURLConnection;
import java.io.*;
import java.net.URL;

// Assumes the reader will try/catch the appropriate exceptions, and clean up
// The connection when they're done with it!

String data = "foo.java-http 1.2";
URL url     = new URL("https://www.hostedgraphite.com/api/v1/sink");
HttpsURLConnection connection = (HttpsURLConnection)url.openConnection();

String key        = "YOUR_API_KEY";
String authHeader = Base64.getEncoder().encodeToString(key.getBytes());

connection.setRequestProperty("Authorization", "Basic " + authHeader);
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Length", String.valueOf(data.getBytes().length));
connection.setUseCaches (false);
connection.setDoInput(true);
connection.setDoOutput(true);

OutputStream wr = connection.getOutputStream();
wr.write(data.getBytes("UTF-8"));
wr.flush();
wr.close();
```

### [Google App Engine HTTP Post](#google-app-engine-http-post)

```java
URLFetchService fetcher= URLFetchServiceFactory.getURLFetchService();
String data = "foo 1.2";
String key  = "YOUR_API_KEY";

String authHeaderString = "Basic " + Base64.encodeBase64String(key).getBytes("ISO-8859-1");
HTTPHeader authHeader   = new HTTPHeader("Authorization", authHeaderString);

HTTPRequest request = new HTTPRequest("https://www.hostedgraphite.com/api/v1/sink", HTTPMethod.POST);
request.getFetchOptions().setDeadline(10);
request.setHeader(authHeader);

request.setPayload(data.getBytes());
HTTPResponse response = fetcher.fetch(request);
```

Your API key can be found on your [account home](https://www.hostedgraphite.com/accounts/profile/) page.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hostedgraphite.com/language-guide/java.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.