Java Code Examples for org.apache.hadoop.metrics.util.MetricsBase#pushMetric()

@Override
public void doUpdates(MetricsContext context) {
  // Get the fair scheduler metrics
  if (scheduler != null) {
    scheduler.submitMetrics(metricsRecord);
  }

  // Get the number of pending calls.
  setNumPendingCalls(sessionNotifier.getNumPendingCalls());

  // Not synchronized on the ClusterManagerMetrics object.
  // The list of metrics in the registry is modified only in the constructor.
  // And pushMetrics() is thread-safe.
  for (MetricsBase m : registry.getMetricsList()) {
    m.pushMetric(metricsRecord);
  }

  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
@Override
public void doUpdates(MetricsContext unused) {
  synchronized (this) {
    for (MetricsBase metricsBase : registry.getMetricsList()) {
      metricsBase.pushMetric(metricsRecord);
    }

    metricsRecord.setMetric("aveMapSlotRefillMsecs",
      tt.getAveMapSlotRefillMsecs());
    metricsRecord.setMetric("aveReduceSlotRefillMsecs",
      tt.getAveReduceSlotRefillMsecs());

    metricsRecord.setMetric("maps_running", tt.getRunningMaps());
    metricsRecord.setMetric("reduces_running", tt.getRunningReduces());
    metricsRecord.setMetric("mapTaskSlots", (short)tt.getMaxActualMapTasks());
    metricsRecord.setMetric("reduceTaskSlots",
                                 (short)tt.getMaxActualReduceTasks());
    metricsRecord.incrMetric("map_tasks_completed",
        numCompletedMapTasks);
    metricsRecord.incrMetric("reduce_tasks_completed",
        numCompletedReduceTasks);
    metricsRecord.incrMetric("tasks_completed", numCompletedTasks);
    metricsRecord.incrMetric("tasks_failed_timeout", timedoutTasks);
    metricsRecord.incrMetric("tasks_failed_ping", tasksFailedPing);
    metricsRecord.setMetric("unaccounted_memory", unaccountedMemory);

    numCompletedMapTasks = 0;
    numCompletedReduceTasks = 0;
    numCompletedTasks = 0;
    timedoutTasks = 0;
    tasksFailedPing = 0;
  }
    metricsRecord.update();
}
 

@Override
public void doUpdates(MetricsContext context) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

@Override
public void doUpdates(MetricsContext context) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Push the metrics to the monitoring subsystem on doUpdate() call.
 */
public void doUpdates(MetricsContext context) {
  
  synchronized (this) {
    // ToFix - fix server to use the following two metrics directly so
    // the metrics do not have be copied here.
    numOpenConnections.set(myServer.getNumOpenConnections());
    callQueueLen.set(myServer.getCallQueueLen());
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
public void doUpdates(MetricsContext unused) {
	synchronized (this) {
		for (MetricsBase m : registry.getMetricsList()) {
			m.pushMetric(metricsRecord);
		}
	}
	metricsRecord.setMetric("client.ls.calls", getAndResetLsCalls());
	metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 * We set the metrics value within  this function before pushing it out. 
 * FSNamesystem updates its own local variables which are
 * light weight compared to Metrics counters. 
 *
 * Some of the metrics are explicity casted to int. Few metrics collectors
 * do not handle long values. It is safe to cast to int for now as all these
 * values fit in int value.
 * Metrics related to DFS capacity are stored in bytes which do not fit in 
 * int, so they are rounded to GB
 */
public void doUpdates(MetricsContext unused) {
  /** 
   * ToFix
   * If the metrics counter were instead stored in the metrics objects themselves
   * we could avoid copying the values on each update.
   */
  synchronized (this) {
    filesTotal.set((int) fsNameSystem.getFilesAndDirectoriesTotal());
    blocksTotal.set((int)fsNameSystem.getBlocksTotal());
    diskSpaceTotalGB.set(roundBytesToGBytes(fsNameSystem.getDiskSpaceTotal()));
    capacityTotalGB.set(roundBytesToGBytes(fsNameSystem.getCapacityTotal()));
    capacityUsedGB.set(roundBytesToGBytes(fsNameSystem.getCapacityUsed()));
    capacityRemainingGB.set(roundBytesToGBytes(fsNameSystem.
                                             getCapacityRemaining()));
    totalLoad.set(fsNameSystem.getTotalLoad());
    corruptBlocks.set((int)fsNameSystem.getCorruptReplicaBlocks());
    excessBlocks.set((int)fsNameSystem.getExcessBlocks());
    pendingDeletionBlocks.set((int)fsNameSystem.getPendingDeletionBlocks());
    pendingReplicationBlocks.set((int)fsNameSystem.
                                 getPendingReplicationBlocks());
    underReplicatedBlocks.set((int)fsNameSystem.getUnderReplicatedBlocks());
    scheduledReplicationBlocks.set((int)fsNameSystem.
                                    getScheduledReplicationBlocks());
    missingBlocks.set((int)fsNameSystem.getMissingBlocksCount());
    blockCapacity.set(fsNameSystem.getBlockCapacity());
    numLeases.set(fsNameSystem.leaseManager.countLease());
    numUnderConstructionFiles.set(fsNameSystem.leaseManager.countPath());
    upgradeTime.set(fsNameSystem.getUpgradeTime());
    
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
public void doUpdates(MetricsContext unused) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
public void doUpdates(MetricsContext unused) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
public void doUpdates(MetricsContext unused) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

@Override
public void doUpdates(MetricsContext unused) {
    synchronized (this) {
        for (MetricsBase m : metricsRegistry.getMetricsList()) {
            m.pushMetric(metricsRecord);
        }
    }
    metricsRecord.update();
}
 

/**
 * Push the metrics to the monitoring subsystem on doUpdate() call.
 */
public void doUpdates(MetricsContext context) {
  
  synchronized (this) {
    // ToFix - fix server to use the following two metrics directly so
    // the metrics do not have be copied here.
    numOpenConnections.set(myServer.getNumOpenConnections());
    callQueueLen.set(myServer.getCallQueueLen());
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 * We set the metrics value within  this function before pushing it out. 
 * FSNamesystem updates its own local variables which are
 * light weight compared to Metrics counters. 
 *
 * Some of the metrics are explicity casted to int. Few metrics collectors
 * do not handle long values. It is safe to cast to int for now as all these
 * values fit in int value.
 * Metrics related to DFS capacity are stored in bytes which do not fit in 
 * int, so they are rounded to GB
 */
public void doUpdates(MetricsContext unused) {
  /** 
   * ToFix
   * If the metrics counter were instead stored in the metrics objects themselves
   * we could avoid copying the values on each update.
   */
  synchronized (this) {
    FSNamesystem fsNameSystem = FSNamesystem.getFSNamesystem();
    filesTotal.set((int)fsNameSystem.getFilesTotal());
    blocksTotal.set((int)fsNameSystem.getBlocksTotal());
    capacityTotalGB.set(roundBytesToGBytes(fsNameSystem.getCapacityTotal()));
    capacityUsedGB.set(roundBytesToGBytes(fsNameSystem.getCapacityUsed()));
    capacityRemainingGB.set(roundBytesToGBytes(fsNameSystem.
                                             getCapacityRemaining()));
    totalLoad.set(fsNameSystem.getTotalLoad());
    corruptBlocks.set((int)fsNameSystem.getCorruptReplicaBlocks());
    excessBlocks.set((int)fsNameSystem.getExcessBlocks());
    pendingDeletionBlocks.set((int)fsNameSystem.getPendingDeletionBlocks());
    pendingReplicationBlocks.set((int)fsNameSystem.
                                 getPendingReplicationBlocks());
    underReplicatedBlocks.set((int)fsNameSystem.getUnderReplicatedBlocks());
    scheduledReplicationBlocks.set((int)fsNameSystem.
                                    getScheduledReplicationBlocks());
    missingBlocks.set((int)fsNameSystem.getMissingBlocksCount());
    blockCapacity.set(fsNameSystem.getBlockCapacity());

    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
public void doUpdates(MetricsContext unused) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

/**
 * Since this object is a registered updater, this method will be called
 * periodically, e.g. every 5 seconds.
 */
public void doUpdates(MetricsContext unused) {
  synchronized (this) {
    for (MetricsBase m : registry.getMetricsList()) {
      m.pushMetric(metricsRecord);
    }
  }
  metricsRecord.update();
}
 

@Override
public void doUpdates(MetricsContext context) {
  LOG.info("Updating metrics");
  int numTrackers = trackerList.size();
  long totalMapRefill = 0;
  long totalReduceRefill = 0;
  int totalRunningMaps = 0;
  int totalRunningReduces = 0;
  int totalMapSlots = 0;
  int totalReduceSlots = 0;
  for (TaskTracker tracker : trackerList) {
    totalMapRefill += tracker.getAveMapSlotRefillMsecs();
    totalReduceRefill += tracker.getAveReduceSlotRefillMsecs();
    totalRunningMaps += tracker.getRunningMaps();
    totalRunningReduces += tracker.getRunningReduces();
    totalMapSlots += tracker.getMaxActualMapTasks();
    totalReduceSlots += tracker.getMaxActualReduceTasks();

    // If the metrics exists, aggregate the task launch msecs for all
    // trackers
    TaskTrackerInstrumentation instrumentation =
        tracker.getTaskTrackerInstrumentation();
    if (instrumentation != null) {
      MetricsTimeVaryingRate taskLaunchMsecs =
          instrumentation.getTaskLaunchMsecs();
      if (taskLaunchMsecs != null) {
        taskLaunchMsecs.pushMetric(null);
        aggTaskLaunchMsecs.inc(
            taskLaunchMsecs.getPreviousIntervalAverageTime());
      }
    }
  }
  long avgMapRefill = totalMapRefill / numTrackers;
  long avgReduceRefill = totalReduceRefill / numTrackers;
  metricsRecord.setMetric("aveMapSlotRefillMsecs", avgMapRefill);
  metricsRecord.setMetric("aveReduceSlotRefillMsecs", avgReduceRefill);
  metricsRecord.setMetric("maps_running", totalRunningMaps);
  metricsRecord.setMetric("reduces_running", totalRunningReduces);
  metricsRecord.setMetric("mapTaskSlots", totalMapSlots);
  metricsRecord.setMetric("reduceTaskSlots", totalReduceSlots);

  for (MetricsBase metricsBase : registry.getMetricsList()) {
    metricsBase.pushMetric(metricsRecord);
  }

  metricsRecord.update();
}