How to use

isNumeric

method

in

com.googlecode.jmxtrans.util.NumberUtils

private boolean isNotValidValue(Object value) {
  return !(isNumeric(value) || stringsValuesAsKey);
}

private boolean isNotValidValue(Object value) {
  return !isNumeric(value);
}

private boolean isNotValidValue(Object value){
  return ! (isNumeric(value) || stringsValuesAsKey);
}

public static boolean isValidNumber(Object value) {
  if (value == null) {
    return false;
  }
  if (value instanceof Number) {
    return isValidNumber((Number) value);
  }
  if (value instanceof String) {
    return isNumeric(value);
  }
  return false;
}

private String computeActualValue(Object value){
  Object transformedValue = valueTransformer.apply(value);
  if(isNumeric(transformedValue)){
    return ":" + transformedValue.toString();
  }
  return "." + transformedValue.toString() + ":" + stringValueDefaultCount.toString();
}

  private String computeActualValue(Object value) {
    Object transformedValue = valueTransformer.apply(value);
    if (isNumeric(transformedValue)) {
      return ":" + transformedValue.toString();
    } else if (transformedValue == null) {
      return ":";
    }

    return "." + transformedValue.toString() + ":" + stringValueDefaultCount;
  }
}

  @Override
  public String serialize(Server server, Query query, Result result) {
    return isNumeric(result.getValue()) ? "" : null;
  }
};

private Number computeActualValue(Object value) {
  Object transformedValue = valueTransformer.apply(value);
  if (isNumeric(transformedValue)) {
    return transformedValue instanceof Number ?
      (Number) transformedValue : Float.valueOf(transformedValue.toString());
  }
  throw new IllegalArgumentException("Only numeric values are supported, enable debug log level for more details.");
}

@Override
public String serialize(Server server, Query query, Result result) throws IOException {
  log.debug("Query result: [{}]", result);
  Object value = result.getValue();
  if (!isNumeric(value)) {
    log.warn("Unable to submit non-numeric value to Kafka: [{}] from result [{}]", value, result);
    return null;
  }
  return createJsonMessage(server, query, result, result.getValuePath(), value);
}

private void serialize(Server server, Query query, List<Result> results, OutputStream outputStream) throws IOException {
  JsonGenerator g = jsonFactory.createGenerator(outputStream, JsonEncoding.UTF8);
  g.useDefaultPrettyPrinter();
  g.writeStartObject();
  g.writeStringField("name", "jmxtrans");
  g.writeStringField("type", "metric");
  g.writeStringField("handler", handler);
  StringBuilder jsonoutput = new StringBuilder();
  List<String> typeNames = getTypeNames();
  for (Result result : results) {
    if (isNumeric(result.getValue())) {
      Object value = result.getValue();
      jsonoutput.append(KeyUtils.getKeyString(server, query, result, typeNames, null)).append(" ")
          .append(value).append(" ")
          .append(TimeUnit.SECONDS.convert(result.getEpoch(), TimeUnit.MILLISECONDS))
          .append(System.getProperty("line.separator"));
    }
  }
  g.writeStringField("output", jsonoutput.toString());
  g.writeEndObject();
  g.flush();
  g.close();
}

if (isNumeric(result.getValue())) {
  g.writeStartObject();
  g.writeStringField("name", KeyUtils.getKeyString(query, result, typeNames));

List<String> typeNames = getTypeNames();
for (Result result : results) {
  if (isNumeric(result.getValue())) {
    g.writeStartObject();
    g.writeStringField("name", KeyUtils.getKeyString(query, result, typeNames));

private void doGenerate(List<Result> results) throws Exception {
  if (isDebugEnabled() && generate) {
    StringBuilder sb = new StringBuilder("\n");
    List<String> keys = new ArrayList<>();
    for (Result res : results) {
      if (isNumeric(res.getValue())) {
        String key = getDataSourceName(getConcatedTypeNameValues(res.getTypeName()), res.getAttributeName(), res.getValuePath());
        if (keys.contains(key)) {
          throw new Exception("Duplicate datasource name found: '" + key
              + "'. Please try to add more typeName keys to the writer to make the name more unique. " + res.toString());
        }
        keys.add(key);
        sb.append("<datasource><!-- ").append(res.getTypeName()).append(":")
            .append(res.getAttributeName()).append(":").append(res.getValuePath())
            .append(" --><name>").append(key)
            .append("</name><type>GAUGE</type><heartbeat>400</heartbeat><min>U</min><max>U</max></datasource>\n");
      }
    }
    log.debug(sb.toString());
  }
}

if (isNumeric(result.getValue()) && filters.contains(keyString[2])) {
  int thresholdPos = filters.indexOf(keyString[2]);
  StringBuilder sb = new StringBuilder();

/**
 * Process a single metric from the given JMX query result with the specified value.
 */
protected void processOneMetric(List<String> resultStrings, Server server, Result result, Object value, String addTagName,
                String addTagValue) {
  String metricName = this.metricNameStrategy.formatName(result);
  //
  // Skip any non-numeric values since OpenTSDB only supports numeric metrics.
  //
  if (isNumeric(value)) {
    StringBuilder resultString = new StringBuilder();
    formatResultString(resultString, metricName, result.getEpoch() / 1000L, value);
    addTags(resultString, server);
    if (addTagName != null) {
      addTag(resultString, addTagName, addTagValue);
    }
    if (!typeNames.isEmpty()) {
      this.addTypeNamesTags(resultString, result);
    }
    resultStrings.add(resultString.toString());
  } else {
    log.debug("Skipping non-numeric value for metric {}; value={}", metricName, value);
  }
}

@Override
public void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
  RrdDef def = getDatabaseTemplateSpec();
  List<String> dsNames = getDsNames(def.getDsDefs());
  Map<String, String> dataMap = new TreeMap<>();
  // go over all the results and look for datasource names that map to
  // keys from the result values
  for (Result res : results) {
    log.debug(res.toString());
    String key = getDataSourceName(getConcatedTypeNameValues(res.getTypeName()), res.getAttributeName(), res.getValuePath());
    if (isNumeric(res.getValue())) {
      log.debug("Generated DataSource name:value: {} : {}", key, res.getValue());
      if (dsNames.contains(key)) {
        dataMap.put(key, res.getValue().toString());
      }
    }
  }
  doGenerate(results);
  if (!dataMap.keySet().isEmpty() && !dataMap.values().isEmpty()) {
    rrdToolUpdate(StringUtils.join(dataMap.keySet(), ':'), StringUtils.join(dataMap.values(), ':'));
  } else {
    log.error("Nothing was logged for query: " + query);
  }
}

if (isNumeric(metric.getValue())) {

@Override
protected void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
  for (Result result : results) {
    log.debug("Query result: [{}]", result);
    if (isNumeric(result.getValue())) {
      Map<String, Object> map = new HashMap<>();
      map.put("serverAlias", server.getAlias());
      map.put("server", server.getHost());
      map.put("port", server.getPort());
      map.put("objDomain", result.getObjDomain());
      map.put("className", result.getClassName());
      map.put("typeName", result.getTypeName());
      map.put("attributeName", result.getAttributeName());
      map.put("valuePath", Joiner.on('/').join(result.getValuePath()));
      map.put("keyAlias", result.getKeyAlias());
      map.put("value", Double.parseDouble(result.getValue().toString()));
      map.put("timestamp", result.getEpoch());
      log.debug("Insert into Elastic: Index: [{}] Type: [{}] Map: [{}]", indexName, ELASTIC_TYPE_NAME, map);
      Index index = new Index.Builder(map).index(indexName).type(ELASTIC_TYPE_NAME).build();
      JestResult addToIndex = jestClient.execute(index);
      if (!addToIndex.isSucceeded()) {
        throw new ElasticWriterException(String.format("Unable to write entry to elastic: %s", addToIndex.getErrorMessage()));
      }
    } else {
      log.warn("Unable to submit non-numeric value to Elastic: [{}] from result [{}]", result.getValue(), result);
    }
  }
}

@Override
public void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
  RrdDb db = null;
  try {
    db = createOrOpenDatabase();
    Sample sample = db.createSample();
    List<String> dsNames = Arrays.asList(db.getDsNames());
    // go over all the results and look for datasource names that map to
    // keys from the result values
    for (Result res : results) {
      String key = StringUtils.join(res.getValuePath(), '.');
      if (dsNames.contains(key) && isNumeric(res.getValue())) {
        sample.setValue(key, Double.valueOf(res.getValue().toString()));
      }
    }
    sample.update();
  } finally {
    if (db != null) {
      db.close();
    }
  }
}

  @Override
  public String serialize(Server server, Query query, Result result) {
    return isNumeric(result.getValue()) ? "" : null;
  }
};