public MetricEmitter()

in sample-apps/spark-awssdkv1/src/main/java/com/amazon/sampleapp/MetricEmitter.java [37:127]
81 lines of code
3 McCabe index (conditional complexity)

  public MetricEmitter() {
    Meter meter =
        GlobalOpenTelemetry.get().meterBuilder("aws-otel").setInstrumentationVersion("1.0").build();

    // give a instanceId appending to the metricname so that we can check the metric for each round
    // of integ-test

    String latencyMetricName = API_LATENCY_METRIC;
    String apiBytesSentMetricName = API_COUNTER_METRIC;
    String totalApiBytesSentMetricName = API_SUM_METRIC;
    String lastLatencyMetricName = API_LAST_LATENCY_METRIC;
    String queueSizeChangeMetricName = API_UP_DOWN_COUNTER_METRIC;
    String actualQueueSizeMetricName = API_UP_DOWN_SUM_METRIC;

    String instanceId = System.getenv("INSTANCE_ID");
    if (instanceId != null && !instanceId.trim().equals("")) {
      latencyMetricName = API_LATENCY_METRIC + "_" + instanceId;
      apiBytesSentMetricName = API_COUNTER_METRIC + "_" + instanceId;
      totalApiBytesSentMetricName = API_SUM_METRIC + "_" + instanceId;
      lastLatencyMetricName = API_LAST_LATENCY_METRIC + "_" + instanceId;
      queueSizeChangeMetricName = API_UP_DOWN_COUNTER_METRIC + "_" + instanceId;
      actualQueueSizeMetricName = API_UP_DOWN_SUM_METRIC + "_" + instanceId;
    }

    meter
        .counterBuilder(apiBytesSentMetricName)
        .setDescription("API request load sent in bytes")
        .setUnit("one")
        .buildWithCallback(
            measurement ->
                measurement.record(
                    apiBytesSent,
                    Attributes.of(
                        DIMENSION_API_NAME, apiNameValue, DIMENSION_STATUS_CODE, statusCodeValue)));

    apiLatencyRecorder =
        meter
            .histogramBuilder(latencyMetricName)
            .setDescription("API latency time")
            .setUnit("ms")
            .build();

    meter
        .upDownCounterBuilder(queueSizeChangeMetricName)
        .setDescription("Queue Size change")
        .setUnit("one")
        .buildWithCallback(
            measurement ->
                measurement.record(
                    queueSizeChange,
                    Attributes.of(
                        DIMENSION_API_NAME, apiNameValue, DIMENSION_STATUS_CODE, statusCodeValue)));

    meter
        .gaugeBuilder(totalApiBytesSentMetricName)
        .setDescription("Total API request load sent in bytes")
        .setUnit("one")
        .ofLongs()
        .buildWithCallback(
            measurement -> {
              measurement.record(
                  totalBytesSent,
                  Attributes.of(
                      DIMENSION_API_NAME, apiNameValue, DIMENSION_STATUS_CODE, statusCodeValue));
            });

    meter
        .gaugeBuilder(lastLatencyMetricName)
        .setDescription("The last API latency observed at collection interval")
        .setUnit("ms")
        .ofLongs()
        .buildWithCallback(
            measurement -> {
              measurement.record(
                  apiLastLatency,
                  Attributes.of(
                      DIMENSION_API_NAME, apiNameValue, DIMENSION_STATUS_CODE, statusCodeValue));
            });
    meter
        .gaugeBuilder(actualQueueSizeMetricName)
        .setDescription("The actual queue size observed at collection interval")
        .setUnit("one")
        .ofLongs()
        .buildWithCallback(
            measurement -> {
              measurement.record(
                  actualQueueSize,
                  Attributes.of(
                      DIMENSION_API_NAME, apiNameValue, DIMENSION_STATUS_CODE, statusCodeValue));
            });
  }