-
Notifications
You must be signed in to change notification settings - Fork 1
/
DynatraceExporterExample.java
184 lines (158 loc) · 7.1 KB
/
DynatraceExporterExample.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
/**
* Copyright 2020 Dynatrace LLC
*
* <p>Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* <p>http://www.apache.org/licenses/LICENSE-2.0
*
* <p>Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.dynatrace.opentelemetry.metric.example;
import static io.opentelemetry.api.common.AttributeKey.stringKey;
import com.dynatrace.opentelemetry.metric.DynatraceMetricExporter;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.DoubleUpDownCounter;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.time.Duration;
import java.util.Objects;
import java.util.Random;
import java.util.logging.LogManager;
import java.util.logging.Logger;
public class DynatraceExporterExample {
private static final Logger logger = Logger.getLogger(DynatraceExporterExample.class.getName());
private static final Random random = new Random();
public static void main(String[] args) throws Exception {
// Create a DynatraceMetricExporter. This method tries to create one from environment variables,
// then from program arguments, and falls back to the default OneAgent endpoint if nothing is
// set.
DynatraceMetricExporter exporter = getExampleExporter(args);
// Creates the meter provider, configuring the metric reader and setting the Dynatrace exporter.
SdkMeterProvider meterProvider =
SdkMeterProvider.builder()
.registerMetricReader(
PeriodicMetricReader.builder(exporter).setInterval(Duration.ofSeconds(30)).build())
.build();
// set up this meter provider as the global meter provider. The global context allows access
// from anywhere in the program.
OpenTelemetrySdk.builder().setMeterProvider(meterProvider).buildAndRegisterGlobal();
// Get or create a named meter instance. If a reference to the MeterProvider ist kept,
// meterProvider.meterBuilder(...) would do the same.
Meter meter =
GlobalOpenTelemetry.getMeterProvider()
.meterBuilder(DynatraceExporterExample.class.getName())
.setInstrumentationVersion("0.5.0")
.build();
// Create a counter
LongCounter counter =
meter
.counterBuilder("example_counter")
.setDescription("Just some counter used as an example")
.setUnit("1")
.build();
// Create an UpDownCounter
DoubleUpDownCounter upDownCounter =
meter.upDownCounterBuilder("updown_counter").ofDoubles().build();
// the gauge callback is called once on every export.
meter
.gaugeBuilder("example_gauge")
.setDescription("a random percentage")
.setUnit("percent")
.buildWithCallback(gauge -> gauge.record(random.nextDouble() * 100));
AttributeKey<String> attributeKeyEnvironment = stringKey("environment");
int sign = 1;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
// Record some data with attributes, then sleep for some time.
counter.add(random.nextInt(10), Attributes.of(attributeKeyEnvironment, "testing"));
counter.add(random.nextInt(20), Attributes.of(attributeKeyEnvironment, "staging"));
// updowncounter grows and gets smaller over time, dependent on sign.
upDownCounter.add(random.nextDouble() * sign);
if (random.nextInt(90) <= 1) {
// flip the sign randomly and seldomly (roughly every 90 seconds).
sign = sign * -1;
}
Thread.sleep(1000);
}
}
private static DynatraceMetricExporter getExampleExporter(String[] args) {
DynatraceMetricExporter exporter;
logger.info("Trying to create a DynatraceMetricExporter from environment variables.");
exporter = tryGetExporterFromEnvironmentVariables();
if (exporter == null) {
logger.info(
"Trying to create a DynatraceMetricExporter from the first two program arguments.");
exporter = tryGetExporterFromArgs(args);
}
if (exporter == null) {
logger.info("Falling back to the default OneAgent exporter.");
exporter = DynatraceMetricExporter.getDefault();
}
return exporter;
}
static {
// read logging.properties and set it to the global LogManager.
LogManager logManager = LogManager.getLogManager();
try {
logManager.readConfiguration(
new FileInputStream(
Objects.requireNonNull(
DynatraceExporterExample.class
.getClassLoader()
.getResource("logging.properties"))
.getFile()));
} catch (NullPointerException | IOException e) {
logger.warning("Failed to read logging setup from logging.properties: " + e.getMessage());
}
}
private static DynatraceMetricExporter tryGetExporterFromArgs(String[] args) {
if (args.length >= 2) {
return makeExampleExporter(args[0], args[1]);
}
logger.info("Failed to set up a DynatraceMetricExporter from program arguments.");
return null;
}
private static DynatraceMetricExporter tryGetExporterFromEnvironmentVariables() {
String endpoint = System.getenv("DYNATRACEAPI_METRICS_INGEST_ENDPOINT");
String token = System.getenv("DYNATRACEAPI_METRICS_INGEST_TOKEN");
if (endpoint != null && !endpoint.isEmpty()) {
logger.info(() -> String.format("Endpoint read from environment: %s", endpoint));
if (token == null) {
logger.info(
"No token set in environment. Assuming that the endpoint is a local OneAgent that does not require an API token.");
} else {
logger.info("Token read from the environment.");
}
// this will pass null to the exporter when no token is set.
return makeExampleExporter(endpoint, token);
}
logger.info("Failed to set up DynatraceMetricExporter from environment variables.");
return null;
}
private static DynatraceMetricExporter makeExampleExporter(String endpoint, String token) {
try {
Attributes exampleDimensions = Attributes.of(stringKey("environment"), "example");
return DynatraceMetricExporter.builder()
.setPrefix("otel.java")
.setDefaultDimensions(exampleDimensions)
.setUrl(endpoint)
.setApiToken(token)
.setEnrichWithOneAgentMetaData(true)
.build();
} catch (MalformedURLException e) {
logger.warning(String.format("Endpoint '%s' is not a valid URL.", endpoint));
return null;
}
}
}