> For the complete documentation index, see [llms.txt](https://docs.hostedgraphite.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.hostedgraphite.com/language-guide/java.md).

# 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.