All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.bigdata.resources.ResourceEvents Maven / Gradle / Ivy

Go to download

Blazegraph(TM) DB Core Platform. It contains all Blazegraph DB dependencies other than Blueprints.

There is a newer version: 2.1.4
Show newest version
/*

Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016.  All rights reserved.

Contact:
     SYSTAP, LLC DBA Blazegraph
     2501 Calvert ST NW #106
     Washington, DC 20008
     licenses@blazegraph.com

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/
/*
 * Created on Mar 24, 2008
 */

package com.bigdata.resources;

import java.text.NumberFormat;

import org.apache.log4j.Logger;
import org.apache.log4j.MDC;

import com.bigdata.btree.AbstractBTree;
import com.bigdata.btree.IndexSegment;
import com.bigdata.counters.CounterSet;
import com.bigdata.journal.BufferMode;
import com.bigdata.journal.IJournal;
import com.bigdata.journal.Journal;
import com.bigdata.journal.TemporaryRawStore;
import com.bigdata.journal.TimestampUtility;

/**
 * Class encapsulates reporting API for resource (index and store files) events.
 * 

* Resource consumption events include *

    *
  1. mutable unisolated indices open on the journal
  2. *
  3. mutable isolated indices open in writable transactions
  4. *
  5. historical read-only indices open on old journals
  6. *
  7. historical read-only index segments
  8. *
* * The latter two classes of event sources exist iff {@link Journal#overflow()} * is handled by creating a new {@link Journal} and evicting data from the old * {@link Journal} asynchronously onto read-optimized {@link IndexSegment}s. *

* * Other resource consumption events deal directly with transactions *

    *
  1. open a transaction
  2. *
  3. close a transaction
  4. *
  5. a heartbeat for each write operation on a transaction is used to update * the resource consumption of the store
  6. *
* *

* Latency events include *

    *
  1. request latency, that is, the time that a request waits on a queue * before being serviced
  2. *
  3. transactions per second
  4. *
* * FIXME Revisit and refactor - this is incomplete as it stands. This is event * focused, which is fine. We also have the {@link CounterSet}s which allow us * to report statistics regarding classes of events. * * @todo use {@link MDC} to put metadata into the logging context {thread, host, * dataService, global index name, local index name (includes the index * partition), etc}. * * @author Bryan Thompson */ public class ResourceEvents { /** * Logger. * * @todo change the logger configuration to write on a JMS queue or JINI * discovered service in order to aggregate results from multiple * hosts in a scale-out solution. */ private static final Logger log = Logger.getLogger(ResourceEvents.class); // /** // * True iff the {@link #log} level is DEBUG or less. // */ // final protected static boolean DEBUG = log.isDebugEnabled(); // // /** // * True iff the {@link #log} level is log.isInfoEnabled() or less. // */ // final protected static boolean log.isInfoEnabled() = log.isInfoEnabled(); static NumberFormat cf; static NumberFormat fpf; /** * Leading zeros without commas used to format the partition identifiers * into index segment file names. This uses 10 digits, which is enough * to represent {@link Integer#MAX_VALUE}. */ static NumberFormat leadingZeros; static { cf = NumberFormat.getNumberInstance(); cf.setGroupingUsed(true); fpf = NumberFormat.getNumberInstance(); fpf.setGroupingUsed(false); fpf.setMaximumFractionDigits(2); leadingZeros = NumberFormat.getIntegerInstance(); leadingZeros.setMinimumIntegerDigits(10); leadingZeros.setGroupingUsed(false); } /** * Report opening of a mutable unisolated named index on an {@link IJournal}. * * @param name * The index name. */ static public void openUnisolatedIndex(final String name) { if (log.isInfoEnabled()) log.info("name=" + name); } /** * Report closing of a mutable unisolated named index on an {@link IJournal}. * * @param name * The index name. * * @todo never invoked since we do not explicitly close out indices and are * not really able to differentiate the nature of the index when it is * finalized (unisolated vs isolated vs index segment can be * identified based on their interfaces). * * @todo add reporting for {@link AbstractBTree#reopen()}. */ static public void closeUnisolatedIndex(final String name) { if (log.isInfoEnabled()) log.info("name=" + name); } /** * Report drop of a named unisolated index. * * @param name * The index name. */ static public void dropUnisolatedIndex(final String name) { if (log.isInfoEnabled()) log.info("name=" + name); } /* * Index segment reporting. */ // /** // * Report that an {@link IndexSegment} has been opened. // * // * @param name // * The index name or null if this is not a named index. // * @param filename // * The name of the file containing the {@link IndexSegment}. // * @param nbytes // * The size of that file in bytes. // * // * @todo memory burden depends on the buffered data (nodes or nodes + // * leaves) // * // * @todo the index name is not being reported since it is not part of the // * extension metadata record at this time. this means that we can not // * aggregate events for index segments for a given named index at this // * time (actually, we can aggregate them by the indexUUID). // */ // static public void openIndexSegment(String name, String filename, // long nbytes) { // // if (log.isInfoEnabled()) // log.info("name=" + name + ", filename=" + filename + ", #bytes=" // + nbytes); // // } // // /** // * Report that an {@link IndexSegment} has been closed. // * // * @param filename // * // * @todo we do not close out index segments based on non-use (e.g., timeout // * or LRU). // */ // static public void closeIndexSegment(String filename) { // // if (log.isInfoEnabled()) // log.info("filename=" + filename); // // } /* * Transaction reporting. * * @todo the clock time for a distributed transaction can be quite different * from the time that a given transaction was actually open on a given data * service. the former is simply [commitTime - startTime] while the latter * depends on the clock times at which the transaction was opened and closed * on the data service. */ /** * Report the start of a new transaction. * * @param startTime * Both the transaction identifier and its global start time. * @param level * The isolation level of the transaction. */ static public void openTx(long startTime) { if (log.isInfoEnabled()) log.info(TimestampUtility.toString(startTime)); } /** * Report completion of a transaction. * * @param tx * The transaction identifier. * @param revisionTime * The timestamp assigned to the revisions written by the * transactions when it commits (non-zero iff this was a writable * transaction that committed successfully and zero otherwise). * @param aborted * True iff the transaction aborted vs completing successfully. */ static public void closeTx(long tx, long revisionTime, boolean aborted) { if (log.isInfoEnabled()) log.info("tx=" + tx + ", revisionTime=" + revisionTime + ", aborted=" + aborted + ", elapsed=" + (revisionTime - tx)); } /** * Report the isolation of a named index by a transaction. * * @param startTime * The transaction identifier. * @param name * The index name. */ static public void isolateIndex(long startTime, String name) { if (log.isInfoEnabled()) log.info("tx=" + startTime + ", name=" + name); /* * Note: there is no separate close for isolated indices - they are * closed when the transaction commits or aborts. read-write indices can * not be closed before the transactions completes, but read-only * indices can be closed early and reopened as required. read-committed * indices are always changing over to the most current committed state * for an index. both read-only and read-committed indices MAY be shared * by more than one transaction (@todo verify that the protocol for * sharing is in place on the journal). */ } /* * Journal file reporting. */ /** * Report the opening of an {@link IJournal} resource. * * @param filename * The filename or null iff the journal was not backed by a file. * @param nbytes * The total #of bytes available on the journal. * @param bufferMode * The buffer mode in use by the journal. */ static public void openJournal(String filename, long nbytes, BufferMode bufferMode) { if (log.isInfoEnabled()) log.info("filename=" + filename + ", #bytes=" + nbytes + ", mode=" + bufferMode); } /** * Report the extension of an {@link IJournal}. * * @param filename * The filename or null iff the journal was not backed by a file. * @param nbytes * The total #of bytes available (vs written) on the journal. * * @todo this does not differentiate between extension of a buffer backing a * journal and extension of a {@link TemporaryRawStore}. This means * that the resources allocated to a transaction vs the unisolated * indices on a journal can not be differentiated. */ static public void extendJournal(String filename, long nbytes) { if (log.isInfoEnabled()) log.info("filename=" + filename + ", #bytes=" + nbytes); } /** * Report close of an {@link IJournal} resource. * * @param filename * The filename or null iff the journal was not backed by a file. */ static public void closeJournal(String filename) { if (log.isInfoEnabled()) log.info("filename=" + filename); } /** * Report deletion of an {@link IJournal} resource. * * @param filename * The filename or null iff the journal was not backed by a file. * * @todo also report deletion of resources for journals that were already * closed but not yet deleted pending client leases or updates of the * metadata index (in the {@link MasterJournal}). */ static public void deleteJournal(String filename) { if (log.isInfoEnabled()) log.info("filename=" + filename); } }




© 2015 - 2025 Weber Informatics LLC | Privacy Policy