com.codahale.metrics.CsvReporter Java Examples

@Override
protected void doNotify(Record notification) {
  for (Object event : Notifications.getLifecycleEvents(notification)) {
    if (event == Notifications.LifecycleEvent.SHUTDOWN) {
      synchronized (REGISTRIES) {
        Map<File, CsvReporter> reporters = REGISTRIES.get(getContext().getMetricRegistry());
        if (reporters != null) {
          CsvReporter reporter = reporters.remove(outputDir);
          if (reporter != null) {
            reporter.stop();
          }
        }
      }
    }
  }
  super.doNotify(notification);
}
 

@Override
public void report(MetricRegistry metricRegistry) {

    JbootMetricCVRReporterConfig cvrReporterConfig = Jboot.config(JbootMetricCVRReporterConfig.class);

    if (StrUtil.isBlank(cvrReporterConfig.getPath())) {
        throw new NullPointerException("csv reporter path must not be null, please config jboot.metrics.reporter.cvr.path in you properties.");
    }

    final CsvReporter reporter = CsvReporter.forRegistry(metricRegistry)
            .formatFor(Locale.US)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build(new File(cvrReporterConfig.getPath()));

    reporter.start(1, TimeUnit.SECONDS);
}
 

private void initMetricsCSVOutput() {
  int timeIntervalMS = conf.getInt(
          SLSConfiguration.METRICS_RECORD_INTERVAL_MS,
          SLSConfiguration.METRICS_RECORD_INTERVAL_MS_DEFAULT);
  File dir = new File(metricsOutputDir + "/metrics");
  if(! dir.exists()
          && ! dir.mkdirs()) {
    LOG.error("Cannot create directory " + dir.getAbsoluteFile());
  }
  final CsvReporter reporter = CsvReporter.forRegistry(metrics)
          .formatFor(Locale.US)
          .convertRatesTo(TimeUnit.SECONDS)
          .convertDurationsTo(TimeUnit.MILLISECONDS)
          .build(new File(metricsOutputDir + "/metrics"));
  reporter.start(timeIntervalMS, TimeUnit.MILLISECONDS);
}
 

private void initMetricsCSVOutput() {
  int timeIntervalMS = conf.getInt(
          SLSConfiguration.METRICS_RECORD_INTERVAL_MS,
          SLSConfiguration.METRICS_RECORD_INTERVAL_MS_DEFAULT);
  File dir = new File(metricsOutputDir + "/metrics");
  if(! dir.exists()
          && ! dir.mkdirs()) {
    LOG.error("Cannot create directory " + dir.getAbsoluteFile());
  }
  final CsvReporter reporter = CsvReporter.forRegistry(metrics)
          .formatFor(Locale.US)
          .convertRatesTo(TimeUnit.SECONDS)
          .convertDurationsTo(TimeUnit.MILLISECONDS)
          .build(new File(metricsOutputDir + "/metrics"));
  reporter.start(timeIntervalMS, TimeUnit.MILLISECONDS);
}
 

@Override
public List<AutoCloseable> start(Params params) {
  SimpleConfiguration config =
      new FluoConfiguration(params.getConfiguration()).getReporterConfiguration("csv");

  String dir = config.getString("dir", "");
  if (!config.getBoolean("enable", false) || dir.isEmpty()) {
    return Collections.emptyList();
  }

  TimeUnit rateUnit = TimeUnit.valueOf(config.getString("rateUnit", "seconds").toUpperCase());
  TimeUnit durationUnit =
      TimeUnit.valueOf(config.getString("durationUnit", "milliseconds").toUpperCase());

  CsvReporter reporter = CsvReporter.forRegistry(params.getMetricRegistry())
      .convertDurationsTo(durationUnit).convertRatesTo(rateUnit).build(new File(dir));
  reporter.start(config.getInt("frequency", 60), TimeUnit.SECONDS);

  log.info("Reporting metrics as csv to directory {}", dir);

  return Collections.singletonList((AutoCloseable) reporter);
}
 

private void initializeMetrics() {
  METRIC_INFOS.addAll(ThreadTerminationMonitor.getMetricInfos());
  METRIC_INFOS.addAll(_coordinator.getMetricInfos());
  METRIC_INFOS.addAll(DatastreamResources.getMetricInfos());

  _jmxReporter = JmxReporterFactory.createJmxReporter(METRIC_REGISTRY);

  if (StringUtils.isNotEmpty(_csvMetricsDir)) {
    LOG.info("Starting CsvReporter in " + _csvMetricsDir);
    File csvDir = new File(_csvMetricsDir);
    if (!csvDir.exists()) {
      LOG.info("csvMetricsDir {} doesn't exist, creating it.", _csvMetricsDir);
      if (!csvDir.mkdirs()) {
        LOG.warn("failed to created csvMetricsDir");
      }
    }

    final CsvReporter reporter = CsvReporter.forRegistry(METRIC_REGISTRY)
        .formatFor(Locale.US)
        .convertRatesTo(SECONDS)
        .convertDurationsTo(MILLISECONDS)
        .build(csvDir);
    reporter.start(1, MINUTES);
  }
}
 

public static void reportTo(File directory) {
	directory.mkdirs();
	MetricRegistry registry = MetricsUtils.getDefaultRegistry();
	ScheduledReporter csvReporter = CsvReporter.forRegistry(registry)
		.convertRatesTo(TimeUnit.SECONDS)
		.convertDurationsTo(TimeUnit.MILLISECONDS)
		.build(directory);
	csvReporter.report();
}
 

@Before
public void setUp() throws SQLException, IOException {
    csvFolder = tmpFolderRule.newFolder("csv");
    mBeanServer=ManagementFactory.getPlatformMBeanServer();
    metricRegistry = new MetricRegistry();
    csvReporter = CsvReporter.forRegistry(metricRegistry)
            .build(csvFolder);
    proxyFactory = new JdbcProxyFactory(metricRegistry, new DefaultMetricNamingStrategy("csv"));
    rawDataSource = H2DbUtil.createDataSource();
    try(Connection connection = rawDataSource.getConnection()) {
        H2DbUtil.initTable(connection);
    }
    dataSource = proxyFactory.wrapDataSource(rawDataSource);
}
 

public static void displayMetrics() {
    ConsoleReporter.forRegistry(registry)
            .build()
            .report();
    CsvReporter.forRegistry(registry)
            .build(new File("target/"))
            .report();
}
 

public void start() {
    switch (METRICS_OPTION) {
    case "":
        logger.info("Skip streaming metricRegistry because it is empty.");
        break;
    // for test purpose
    case "console":
        logger.info("Use console to collect streaming metricRegistry.");
        ConsoleReporter consoleReporter = ConsoleReporter.forRegistry(metricRegistry)
                .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS).build();
        consoleReporter.start(STREAM_METRICS_INTERVAL, TimeUnit.SECONDS);
        break;
    case "csv":
        File metricsFolder = new File("stream_metrics_csv");
        if (!metricsFolder.exists()) {
            boolean res = metricsFolder.mkdirs();
            if (!res) {
                logger.error("Cannot create dir for stream_metrics_csv");
                break;
            }
        }
        logger.info("Collect streaming metricRegistry in csv format.");
        CsvReporter scvReporter = CsvReporter.forRegistry(metricRegistry).convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS).build(metricsFolder);
        scvReporter.start(STREAM_METRICS_INTERVAL, TimeUnit.SECONDS);
        break;
    case "jmx":
        final JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
        break;
    default:
        logger.info("Skip metricRegistry because the option {} is not identified.", METRICS_OPTION);
    }
}
 

public CodahaleMetricsAssembler withCsvReporter( File outDirectory, long period, TimeUnit timeunit )
{
    declaration.reportersFactories.add( metricRegistry -> {
        CsvReporter reporter = CsvReporter.forRegistry( metricRegistry ).build( outDirectory );
        reporter.start( period, timeunit );
        return reporter;
    });
    return this;
}
 

@Override
public CsvReporter get() {
    return CsvReporter.forRegistry(metricRegistry)
            .formatFor(configuration.getLocale())
            .convertDurationsTo(configuration.getUnitDurations())
            .convertRatesTo(configuration.getUnitRates())
            .filter(new RegexMetricFilter(configuration.getIncludeMetrics()))
            .build(configuration.getDirectory());
}
 

@Override
protected void configure() {
    bind(CsvReporter.class).toProvider(CsvReporterProvider.class);

    addConfigBeans();
    addInitializer(MetricsCsvReporterService.class);
}
 

public void start() {
    switch (METRICS_OPTION) {
    case "":
        logger.info("Skip streaming metricRegistry because it is empty.");
        break;
    // for test purpose
    case "console":
        logger.info("Use console to collect streaming metricRegistry.");
        ConsoleReporter consoleReporter = ConsoleReporter.forRegistry(metricRegistry)
                .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS).build();
        consoleReporter.start(STREAM_METRICS_INTERVAL, TimeUnit.SECONDS);
        break;
    case "csv":
        File metricsFolder = new File("stream_metrics_csv");
        if (!metricsFolder.exists()) {
            boolean res = metricsFolder.mkdirs();
            if (!res) {
                logger.error("Cannot create dir for stream_metrics_csv");
                break;
            }
        }
        logger.info("Collect streaming metricRegistry in csv format.");
        CsvReporter scvReporter = CsvReporter.forRegistry(metricRegistry).convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS).build(metricsFolder);
        scvReporter.start(STREAM_METRICS_INTERVAL, TimeUnit.SECONDS);
        break;
    case "jmx":
        final JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
        break;
    default:
        logger.info("Skip metricRegistry because the option {} is not identified.", METRICS_OPTION);
    }
}
 

@Test
public void get() throws Exception {
    final CsvReporterProvider provider = new CsvReporterProvider(new MetricsCsvReporterConfiguration(), new MetricRegistry());
    final CsvReporter reporter = provider.get();
    assertNotNull(reporter);
}
 

@Inject
public MetricsCsvReporterService(CsvReporter csvReporter, MetricsCsvReporterConfiguration configuration) {
    this.csvReporter = requireNonNull(csvReporter);
    this.configuration = requireNonNull(configuration);
}
 

public StartReportingMetricsToCSV(CommandBuilder builder, Config config, Command parent, Command child, MorphlineContext context) {
  super(builder, config, parent, child, context);      
  
  MetricFilter filter = PatternMetricFilter.parse(getConfigs(), config);
  TimeUnit defaultDurationUnit = getConfigs().getTimeUnit(config, "defaultDurationUnit", TimeUnit.MILLISECONDS);
  TimeUnit defaultRateUnit = getConfigs().getTimeUnit(config, "defaultRateUnit", TimeUnit.SECONDS); 
  long frequency = getConfigs().getNanoseconds(config, "frequency", 10 * 1000L * 1000 * 1000); // 10 seconds
  if (LOG.isTraceEnabled()) {
    LOG.trace("availableLocales: {}", Joiner.on("\n").join(Locale.getAvailableLocales()));
  }
  Locale locale = getConfigs().getLocale(config, "locale", Locale.getDefault());
  this.outputDir = new File(getConfigs().getString(config, "outputDir"));
  validateArguments();
  
  MetricRegistry registry = context.getMetricRegistry();
  synchronized (REGISTRIES) {
    Map<File, CsvReporter> reporters = REGISTRIES.get(registry);
    if (reporters == null) {
      reporters = Maps.newHashMap();
      REGISTRIES.put(registry, reporters);
    }
    CsvReporter reporter = reporters.get(outputDir);
    if (reporter == null) {
      Builder reporterBuilder = CsvReporter.forRegistry(registry)
          .filter(filter)
          .convertDurationsTo(defaultDurationUnit)
          .convertRatesTo(defaultRateUnit)
          .formatFor(locale);
          
      reporter = reporterBuilder.build(outputDir);
      outputDir.mkdirs();
      if (!outputDir.isDirectory()) {
        throw new MorphlineCompilationException("Directory not found: " + outputDir, config);
      }
      if (!outputDir.canWrite()) {
        throw new MorphlineCompilationException("Directory not writeable: " + outputDir, config);
      }
      reporter.start(frequency, TimeUnit.NANOSECONDS);
      reporters.put(outputDir, reporter);
    }
  }
}