[stajistics] push by troy.kin...@gmail.com - Fixed maven 3 site reporting for submodules. Refactored StatsFactory i... on 2011-08-01 05:39 GMT

7 views

Skip to first unread message

staji...@googlecode.com

unread,

Aug 1, 2011, 1:39:48 AM8/1/11

to stajist...@googlegroups.com

Revision: 3d74ff0deaab
Author: troy.k...@gmail.com
Date: Sun Jul 31 22:38:26 2011
Log: Fixed maven 3 site reporting for submodules. Refactored
StatsFactory into an interface for better decoupling and easier unit
testing.
http://code.google.com/p/stajistics/source/detail?r=3d74ff0deaab

Added:
/stajistics-core/src/main/java/org/stajistics/DefaultStatsFactory.java
/stajistics-core/src/main/java/org/stajistics/Stats.java
/stajistics-core/src/test/java/org/stajistics/DefaultStatsFactoryTest.java
/stajistics-core/src/test/java/org/stajistics/StatsKeyUtilTest.java
/stajistics-core/src/test/java/org/stajistics/StatsTest.java
Deleted:

/stajistics-core/src/main/java/org/stajistics/tracker/DefaultTrackerLocator.java

/stajistics-core/src/main/java/org/stajistics/tracker/NullTrackerLocator.java
/stajistics-core/src/main/java/org/stajistics/tracker/TrackerLocator.java
/stajistics-core/src/test/java/org/stajistics/StatsFactoryTest.java

/stajistics-core/src/test/java/org/stajistics/tracker/DefaultTrackerLocatorTest.java

/stajistics-core/src/test/java/org/stajistics/tracker/NullTrackerLocatorTest.java
Modified:
/pom.xml
/src/site/apt/index.apt
/src/site/site.xml
/stajistics-core/pom.xml
/stajistics-core/src/main/java/org/stajistics/DefaultStatsManager.java
/stajistics-core/src/main/java/org/stajistics/StatsFactory.java
/stajistics-core/src/main/java/org/stajistics/StatsKeyUtil.java
/stajistics-core/src/main/java/org/stajistics/StatsManager.java
/stajistics-core/src/main/java/org/stajistics/UncaughtExceptionHandler.java
/stajistics-core/src/main/java/org/stajistics/aop/LifeCycleMonitor.java
/stajistics-core/src/main/java/org/stajistics/aop/StatsDecorators.java
/stajistics-core/src/main/java/org/stajistics/aop/StatsProxy.java

/stajistics-core/src/main/java/org/stajistics/io/StatsFilterInputStream.java

/stajistics-core/src/main/java/org/stajistics/io/StatsFilterOutputStream.java
/stajistics-core/src/main/java/org/stajistics/io/StatsFilterReader.java
/stajistics-core/src/main/java/org/stajistics/io/StatsFilterWriter.java
/stajistics-core/src/main/java/org/stajistics/util/FastPutsLinkedMap.java
/stajistics-core/src/main/java/org/stajistics/util/Misc.java
/stajistics-core/src/test/java/org/stajistics/DefaultStatsManagerTest.java
/stajistics-core/src/test/java/org/stajistics/Issue32Test.java
/stajistics-core/src/test/java/org/stajistics/TestApp.java
/stajistics-core/src/test/java/org/stajistics/TestUtil.java
/stajistics-core/src/test/java/org/stajistics/aop/StatsDecoratorsTest.java
/stajistics-core/src/test/java/org/stajistics/aop/StatsProxyTest.java

/stajistics-core/src/test/java/org/stajistics/aop/StatsSelectiveProxyTest.java

/stajistics-core/src/test/java/org/stajistics/bootstrap/AbstractStatsManagerFactoryTestCase.java

/stajistics-core/src/test/resources/org/stajistics/configuration/xml/testConfig.xml

/stajistics-examples/src/main/java/org/stajistics/examples/basic/MethodTimeDuration.java
/stajistics-jdbc/pom.xml

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/DefaultJDBCProxyFactory.java

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsCallableStatementWrapper.java

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsConnectionWrapper.java

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsPooledConnectionWrapper.java

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsPreparedStatementWrapper.java

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsResultSetWrapper.java

/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsStatementWrapper.java
/stajistics-servlet/pom.xml

/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsFilter.java

/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsHttpServletRequest.java

/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsServletInputStream.java

/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsServletOutputStream.java

/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/http/StatsHttpSessionListener.java

/stajistics-servlet/src/test/java/org/stajistics/integration/servlet/StatsFilterTest.java

=======================================
--- /dev/null
+++ /stajistics-core/src/main/java/org/stajistics/DefaultStatsFactory.java
Sun Jul 31 22:38:26 2011
@@ -0,0 +1,248 @@
+package org.stajistics;
+
+import static org.stajistics.Util.assertNotEmpty;
+import static org.stajistics.Util.assertNotNull;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.stajistics.configuration.StatsConfig;
+import org.stajistics.configuration.StatsConfigBuilder;
+import org.stajistics.tracker.NullTracker;
+import org.stajistics.tracker.Tracker;
+import org.stajistics.tracker.incident.CompositeIncidentTracker;
+import org.stajistics.tracker.incident.IncidentTracker;
+import org.stajistics.tracker.manual.ManualTracker;
+import org.stajistics.tracker.span.CompositeSpanTracker;
+import org.stajistics.tracker.span.SpanTracker;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class DefaultStatsFactory implements StatsFactory {
+
+ private static final Logger logger =
LoggerFactory.getLogger(DefaultStatsFactory.class);
+
+ protected final StatsManager statsManager;
+
+ public DefaultStatsFactory(final StatsManager statsManager) {
+ assertNotNull(statsManager, "statsManager");
+ this.statsManager = statsManager;
+ }
+
+ @Override
+ public StatsManager getManager() {
+ return statsManager;
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return statsManager.isEnabled();
+ }
+
+ @SuppressWarnings("unchecked")
+ protected <T extends Tracker> T getTracker(final Class<T>
expectedTrackerType, final StatsKey key) {
+ Tracker result = null;
+
+ try {
+ assertNotNull(key, "key");
+
+ if (statsManager.isEnabled()) {
+ StatsConfig config =
statsManager.getConfigManager().getOrCreateConfig(key/*,
expectedTrackerType*/);
+ if (config.isEnabled()) {
+ result = config.getTrackerFactory()
+ .createTracker(key,
statsManager.getSessionManager());
+ }
+ }
+
+ } catch (Exception e) {
+ logger.error("Failed to obtain a " +
expectedTrackerType.getSimpleName(), e);
+ statsManager.getUncaughtExceptionHandler()
+ .uncaughtException(key, e);
+ }
+
+ if (result == null) {
+ result = NullTracker.getInstance();
+ }
+
+ return (T) result;
+ }
+
+ @SuppressWarnings("unchecked")
+ protected <T extends Tracker> T getCompositeTracker(final Class<T>
expectedTrackerType, final StatsKey... keys) {
+
+ Tracker result = null;
+
+ try {
+ assertNotNull(expectedTrackerType, "expectedTrackerType");
+ assertNotEmpty(keys, "keys");
+ if (keys.length == 1) {
+ return getTracker(expectedTrackerType, keys[0]);
+ }
+
+ if (expectedTrackerType == SpanTracker.class) {
+ final SpanTracker[] trackers = new
SpanTracker[keys.length];
+ for (int i = 0; i < keys.length; i++) {
+ trackers[i] = getTracker(SpanTracker.class, keys[i]);
+ }
+
+ result = new CompositeSpanTracker(trackers);
+
+ } else if (expectedTrackerType == IncidentTracker.class) {
+ final IncidentTracker[] trackers = new
IncidentTracker[keys.length];
+ for (int i = 0; i < keys.length; i++) {
+ trackers[i] = getTracker(IncidentTracker.class,
keys[i]);
+ }
+
+ result = new CompositeIncidentTracker(trackers);
+
+ } else {
+ throw new RuntimeException("Tracker type does not support
composites: " + expectedTrackerType.getName());
+ }
+
+ } catch (Exception e) {
+ logger.error("Failed to obtain a " +
expectedTrackerType.getSimpleName(), e);
+
+ StatsKey key = null;
+ if (keys.length > 0) {
+ key = keys[0];
+ }
+
+ statsManager.getUncaughtExceptionHandler()
+ .uncaughtException(key, e);
+ }
+
+ if (result == null) {
+ result = NullTracker.getInstance();
+ }
+
+ return (T) result;
+ }
+
+ @Override
+ public SpanTracker getSpanTracker(final String keyName) {
+ return getTracker(SpanTracker.class, newKey(keyName));
+ }
+
+ @Override
+ public SpanTracker getSpanTracker(final StatsKey key) {
+ return getTracker(SpanTracker.class, key);
+ }
+
+ @Override
+ public SpanTracker getSpanTracker(final StatsKey... keys) {
+ return getCompositeTracker(SpanTracker.class, keys);
+ }
+
+ @Override
+ public SpanTracker track(final String keyName) {
+ return getTracker(SpanTracker.class, newKey(keyName)).track();
+ }
+
+ @Override
+ public SpanTracker track(final StatsKey key) {
+ return getTracker(SpanTracker.class, key).track();
+ }
+
+ @Override
+ public SpanTracker track(final StatsKey... keys) {
+ return getCompositeTracker(SpanTracker.class, keys).track();
+ }
+
+
+ @Override
+ public IncidentTracker getIncidentTracker(final String keyName) {
+ return getTracker(IncidentTracker.class, newKey(keyName));
+ }
+
+ @Override
+ public IncidentTracker getIncidentTracker(final StatsKey key) {
+ return getTracker(IncidentTracker.class, key);
+ }
+
+ @Override
+ public void incident(final String keyName) {
+ getTracker(IncidentTracker.class, newKey(keyName)).incident();
+ }
+
+ @Override
+ public void incident(final StatsKey key) {
+ getTracker(IncidentTracker.class, key).incident();
+ }
+
+ @Override
+ public void incident(final StatsKey... keys) {
+ getCompositeTracker(IncidentTracker.class, keys).incident();
+ }
+
+ @Override
+ public void failure(final Throwable failure,
+ final String keyName) {
+ getIncidentTracker(StatsKeyUtil.keyForFailure(newKey(keyName),
failure)).incident();
+ }
+
+ @Override
+ public void failure(final Throwable failure, final StatsKey key) {
+ getIncidentTracker(StatsKeyUtil.keyForFailure(key,
failure)).incident();
+ }
+
+ @Override
+ public void failure(final Throwable failure, final StatsKey... keys) {
+ try {
+ assertNotEmpty(keys, "keys");
+
+ for (StatsKey key : keys) {
+ getIncidentTracker(StatsKeyUtil.keyForFailure(key,
failure)).incident();
+ }
+ } catch (Exception e) {
+ logger.error("Failed to report a failure", e);
+ statsManager.getUncaughtExceptionHandler()
+ .uncaughtException(null, e);
+ }
+ }
+
+ @Override
+ public ManualTracker getManualTracker(final String keyName) {
+ return getTracker(ManualTracker.class, newKey(keyName));
+ }
+
+ @Override
+ public ManualTracker getManualTracker(final StatsKey key) {
+ return getTracker(ManualTracker.class, key);
+ }
+
+ @Override
+ public StatsKey newKey(final String name) {
+ try {
+ return statsManager.getKeyFactory()
+ .createKey(name);
+ } catch (Exception e) {
+ logger.error("Failed to create a " +
StatsKey.class.getSimpleName() + " for key name: " + name, e);
+ statsManager.getUncaughtExceptionHandler()
+ .uncaughtException(null, e);
+ return NullStatsKey.getInstance();
+ }
+ }
+
+ @Override
+ public StatsKeyBuilder buildKey(final String name) {
+ try {
+ return statsManager.getKeyFactory()
+ .createKeyBuilder(name);
+ } catch (Exception e) {
+ logger.error("Failed to create a " +
StatsKeyBuilder.class.getSimpleName() + " for key name: " + name, e);
+ statsManager.getUncaughtExceptionHandler()
+ .uncaughtException(null, e);
+ return NullStatsKeyBuilder.getInstance();
+ }
+ }
+
+ @Override
+ public StatsConfigBuilder buildConfig() {
+ return statsManager.getConfigBuilderFactory()
+ .createConfigBuilder();
+ }
+
+
+}
=======================================
--- /dev/null
+++ /stajistics-core/src/main/java/org/stajistics/Stats.java Sun Jul 31
22:38:26 2011
@@ -0,0 +1,118 @@
+package org.stajistics;
+
+import static org.stajistics.Util.assertNotNull;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.stajistics.bootstrap.DefaultStatsManagerFactory;
+import org.stajistics.bootstrap.StatsManagerFactory;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class Stats {
+
+ private static final Logger logger =
LoggerFactory.getLogger(Stats.class);
+
+ protected static final String PROP_MANAGER_FACTORY =
StatsManagerFactory.class.getName();
+ protected static final String PROP_AUTO_INIT_DEFAULT_MANAGER =
StatsFactory.class.getName() + ".autoInitDefaultManager";
+
+ private Stats() {}
+
+ public static StatsFactory getFactory(final Class<?> aClass) {
+ assertNotNull(aClass, "aClass");
+
+ final StatsManagerRegistry reg =
StatsManagerRegistry.getInstance();
+ String pkg = aClass.getPackage().getName();
+
+ do {
+ String namespace = pkg;
+ if (reg.isStatsManagerDefined(namespace)) {
+ StatsManager statsManager = reg.getStatsManager(namespace);
+ if (statsManager != null) {
+ logger.debug("Found StatsManager at namespace '{}' for
class '{}'.", namespace, aClass);
+ return new DefaultStatsFactory(statsManager);
+ }
+ }
+
+ int i = pkg.lastIndexOf('.');
+ if (i > -1) {
+ pkg = pkg.substring(0, i);
+ } else {
+ pkg = null;
+ }
+ } while (pkg != null);
+
+ logger.debug("No matching namespaces defined for class '{}'.
Attemping to use default namespace.", aClass);
+
+ return getFactory(StatsConstants.DEFAULT_NAMESPACE);
+ }
+
+ public static StatsFactory getFactory(final String namespace) {
+ assertNotNull(namespace, "namespace");
+ final StatsManagerRegistry reg =
StatsManagerRegistry.getInstance();
+
+ if (reg.isStatsManagerDefined(namespace)) {
+ StatsManager statsManager = reg.getStatsManager(namespace);
+ return new DefaultStatsFactory(statsManager);
+ }
+
+ // Namespace not found
+
+ if (namespace.equals(StatsConstants.DEFAULT_NAMESPACE)) {
+ boolean autoInitDefaultManager =
Boolean.parseBoolean(System.getProperty(PROP_AUTO_INIT_DEFAULT_MANAGER,
+
Boolean.TRUE.toString()));
+ if (autoInitDefaultManager) {
+ loadDefaultStatsManager();
+ StatsManager statsManager = reg.getStatsManager(namespace);
+ return new DefaultStatsFactory(statsManager);
+ }
+ }
+
+ throw new StatsNamespaceNotFoundException(namespace);
+ }
+
+ protected static StatsManager loadDefaultStatsManager() {
+
+ StatsManager manager = null;
+
+ try {
+ StatsManagerFactory managerFactory =
loadStatsManagerFactoryFromProperties();
+ if (managerFactory != null) {
+ manager =
managerFactory.createManager(StatsConstants.DEFAULT_NAMESPACE);
+ if (manager == null) {
+ logger.error(StatsManagerFactory.class.getSimpleName()
+ " created null " +
+ StatsManager.class.getSimpleName() + ": "
+ managerFactory.getClass());
+ }
+ }
+
+ } catch (Exception e) {
+ logger.error("Failed to load " +
StatsManager.class.getSimpleName() + ": " + e.toString(), e);
+ }
+
+ if (manager == null) {
+ manager = new
DefaultStatsManagerFactory().createManager(StatsConstants.DEFAULT_NAMESPACE);
+ }
+
+ return manager;
+ }
+
+ protected static StatsManagerFactory
loadStatsManagerFactoryFromProperties() throws Exception {
+ StatsManagerFactory managerFactory = null;
+
+ String managerFactoryClassName =
System.getProperty(PROP_MANAGER_FACTORY);
+ if (managerFactoryClassName != null) {
+ @SuppressWarnings("unchecked")
+ Class<StatsManagerFactory> managerFactoryClass =
+
(Class<StatsManagerFactory>)Class.forName(managerFactoryClassName);
+
+ managerFactory = managerFactoryClass.newInstance();
+ }
+
+ return managerFactory;
+ }
+
+
+}
=======================================
--- /dev/null
+++
/stajistics-core/src/test/java/org/stajistics/DefaultStatsFactoryTest.java
Sun Jul 31 22:38:26 2011
@@ -0,0 +1,291 @@
+package org.stajistics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import java.util.Iterator;
+
+import org.jmock.Expectations;
+import org.junit.Before;
+import org.junit.Test;
+import org.stajistics.bootstrap.StatsManagerFactory;
+import org.stajistics.configuration.StatsConfig;
+import org.stajistics.configuration.StatsConfigBuilder;
+import org.stajistics.configuration.StatsConfigBuilderFactory;
+import org.stajistics.tracker.incident.IncidentTracker;
+import org.stajistics.tracker.manual.ManualTracker;
+import org.stajistics.tracker.span.CompositeSpanTracker;
+import org.stajistics.tracker.span.SpanTracker;
+
+/**
+ * @author The Stajistics Project
+ */
+public class DefaultStatsFactoryTest extends AbstractStajisticsTestCase {
+
+ private StatsFactory factory;
+
+ private StatsManager mockManager;
+ private StatsKey mockKey;
+ private StatsConfig mockConfig;
+
+ @Before
+ public void setUp() {
+ mockKey = mockery.mock(StatsKey.class);
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey, "key1");
+
+ mockManager = TestUtil.createMockStatsManager(mockery, mockKey);
+ mockConfig = mockery.mock(StatsConfig.class);
+
+ TestUtil.buildStatsConfigExpectations(mockery, mockKey,
mockConfig);
+
+ factory = new DefaultStatsFactory(mockManager);
+
+ mockery.checking(new Expectations() {{
+ allowing(mockKey).getName();
+ will(returnValue(mockKey.getName()));
+ }});
+ }
+
+ private SpanTracker expectSpanTrackerConfiguration(final StatsKey
mockKey,
+ final StatsConfig
mockConfig) {
+ final SpanTracker mockTracker =
mockery.mock(SpanTracker.class, "spanTracker_" + mockKey.getName());
+ TestUtil.expectKeyConfiguration(mockery, mockManager, mockKey,
mockConfig, mockTracker);
+ return mockTracker;
+ }
+
+ private IncidentTracker expectIncidentTrackerConfiguration(final
StatsKey mockKey,
+ final
StatsConfig mockConfig) {
+
+ final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class, "incidentTracker_" + mockKey.getName());
+ TestUtil.expectKeyConfiguration(mockery, mockManager, mockKey,
mockConfig, mockTracker);
+ return mockTracker;
+ }
+
+ private ManualTracker expectManualTrackerConfiguration(final StatsKey
mockKey,
+ final
StatsConfig mockConfig) {
+ final ManualTracker mockTracker =
mockery.mock(ManualTracker.class, "manualTracker_" + mockKey.getName());
+ TestUtil.expectKeyConfiguration(mockery, mockManager, mockKey,
mockConfig, mockTracker);
+ return mockTracker;
+ }
+
+ @Test
+ public void testConstructWithNullManager() {
+ try {
+ new DefaultStatsFactory(null);
+ fail("Allowed construction of " +
StatsFactory.class.getSimpleName() + " with null statsManager");
+ } catch (NullPointerException npe) {
+ assertEquals("statsManager", npe.getMessage());
+ }
+ }
+
+ @Test
+ public void testGetManager() {
+ assertSame(mockManager, factory.getManager());
+ }
+
+ @Test
+ public void testTrackWithKeyName() {
+ final SpanTracker mockTracker =
expectSpanTrackerConfiguration(mockKey, mockConfig);
+
+ mockery.checking(new Expectations() {{
+ one(mockTracker).track();
+ will(returnValue(mockTracker));
+ }});
+
+ assertEquals(mockTracker, factory.track(mockKey.getName()));
+ }
+
+ @Test
+ public void testStartWithStatsKey() {
+ final SpanTracker mockTracker =
expectSpanTrackerConfiguration(mockKey, mockConfig);
+
+ mockery.checking(new Expectations() {{
+ one(mockTracker).track();
+ will(returnValue(mockTracker));
+ }});
+
+ assertEquals(mockTracker, factory.track(mockKey));
+ }
+
+ @Test
+ public void testSpanTrackWithStatsKeys() {
+ final SpanTracker mockTracker =
expectSpanTrackerConfiguration(mockKey, mockConfig);
+
+ final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "key2");
+
+ final StatsConfig mockConfig2 =
mockery.mock(StatsConfig.class, "statsConfig2");
+ TestUtil.buildStatsConfigExpectations(mockery, mockKey2,
mockConfig2);
+ final SpanTracker mockTracker2 =
expectSpanTrackerConfiguration(mockKey2, mockConfig2);
+
+ mockery.checking(new Expectations() {{
+ one(mockTracker).track();
+ will(returnValue(mockTracker));
+ one(mockTracker2).track();
+ will(returnValue(mockTracker2));
+ }});
+
+ SpanTracker resultTracker = factory.track(mockKey, mockKey2);
+ assertEquals(CompositeSpanTracker.class, resultTracker.getClass());
+ Iterator<SpanTracker> itr =
((CompositeSpanTracker)resultTracker).composites().iterator();
+ assertSame(mockTracker, itr.next());
+ assertSame(mockTracker2, itr.next());
+ }
+
+ @Test
+ public void testIncidentWithKeyName() {
+ final IncidentTracker mockTracker =
expectIncidentTrackerConfiguration(mockKey, mockConfig);
+
+ mockery.checking(new Expectations() {{
+ one(mockTracker).incident();
+ will(returnValue(mockTracker));
+ }});
+
+ factory.incident(mockKey.getName());
+ }
+
+ @Test
+ public void testIncidentWithStatsKey() {
+ final IncidentTracker mockTracker =
expectIncidentTrackerConfiguration(mockKey, mockConfig);
+
+ mockery.checking(new Expectations() {{
+ one(mockTracker).incident();
+ will(returnValue(mockTracker));
+ }});
+
+ factory.incident(mockKey);
+ }
+
+ @Test
+ public void testIncidentWithStatsKeys() {
+ final IncidentTracker mockTracker =
expectIncidentTrackerConfiguration(mockKey, mockConfig);
+
+ final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "key2");
+
+ final StatsConfig mockConfig2 =
mockery.mock(StatsConfig.class, "statsConfig2");
+ TestUtil.buildStatsConfigExpectations(mockery, mockKey2,
mockConfig2);
+ final IncidentTracker mockTracker2 =
expectIncidentTrackerConfiguration(mockKey2, mockConfig2);
+
+ mockery.checking(new Expectations() {{
+ one(mockTracker).incident();
+ will(returnValue(mockTracker));
+ one(mockTracker2).incident();
+ will(returnValue(mockTracker2));
+ }});
+
+ factory.incident(mockKey, mockKey2);
+ }
+
+ @Test
+ public void testFailureWithKeyName() {
+ final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class, "incidentTracker_" + mockKey.getName());
+ final StatsKeyBuilder mockKeyBuilder =
TestUtil.expectKeyConfiguration(mockery, mockManager, mockKey, mockConfig,
mockTracker);
+
+ final StatsKey mockKey2 = mockery.mock(StatsKey.class, "key2");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "key2");
+ final StatsConfig mockConfig2 =
mockery.mock(StatsConfig.class, "config2");
+ TestUtil.buildStatsConfigExpectations(mockery, mockKey2,
mockConfig2);
+ final IncidentTracker mockTracker2 =
expectIncidentTrackerConfiguration(mockKey2, mockConfig2);
+
+ final Exception e = new Exception();
+
+ mockery.checking(new Expectations() {{
+ one(mockKeyBuilder).withNameSuffix("exception");
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).withAttribute("threw",
e.getClass().getName());
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).newKey();
+ will(returnValue(mockKey2));
+
+ one(mockTracker2).incident();
+ will(returnValue(mockTracker2));
+ }});
+
+ factory.failure(e, mockKey.getName());
+ }
+
+ @Test
+ public void testFailureWithStatsKey() {
+ final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class, "incidentTracker_" + mockKey.getName());
+ final StatsKeyBuilder mockKeyBuilder =
TestUtil.expectKeyConfiguration(mockery, mockManager, mockKey, mockConfig,
mockTracker);
+
+ final StatsKey mockKey2 = mockery.mock(StatsKey.class, "key2");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "key2");
+ final StatsConfig mockConfig2 =
mockery.mock(StatsConfig.class, "config2");
+ TestUtil.buildStatsConfigExpectations(mockery, mockKey2,
mockConfig2);
+ final IncidentTracker mockTracker2 =
expectIncidentTrackerConfiguration(mockKey2, mockConfig2);
+
+ final Exception e = new Exception();
+
+ mockery.checking(new Expectations() {{
+ one(mockKeyBuilder).withNameSuffix("exception");
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).withAttribute("threw",
e.getClass().getName());
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).newKey();
+ will(returnValue(mockKey2));
+
+ one(mockTracker2).incident();
+ will(returnValue(mockTracker2));
+ }});
+
+ factory.failure(e, mockKey);
+ }
+
+ @Test
+ public void testManualWithKeyName() {
+ final ManualTracker mockTracker =
expectManualTrackerConfiguration(mockKey, mockConfig);
+
+ assertSame(mockTracker,
factory.getManualTracker(mockKey.getName()));
+ }
+
+ @Test
+ public void testManualWithStatsKey() {
+ final ManualTracker mockTracker =
expectManualTrackerConfiguration(mockKey, mockConfig);
+
+ assertSame(mockTracker, factory.getManualTracker(mockKey));
+ }
+
+ @Test
+ public void testNewKey() {
+ mockery.checking(new Expectations() {{
+
one(mockManager.getKeyFactory()).createKey(with(mockKey.getName()));
+ will(returnValue(mockKey));
+ }});
+
+ assertSame(mockKey, factory.newKey(mockKey.getName()));
+ }
+
+ @Test
+ public void testBuildKey() {
+ StatsKeyBuilder mockKeyBuilder =
TestUtil.expectKeyConfiguration(mockery, mockManager, mockKey, mockConfig,
null);
+
+ assertSame(mockKeyBuilder, factory.buildKey(mockKey.getName()));
+ }
+
+ @Test
+ public void testBuildConfig() {
+ final StatsConfigBuilder mockConfigBuilder =
mockery.mock(StatsConfigBuilder.class);
+
+ mockery.checking(new Expectations() {{
+
one(mockManager.getConfigBuilderFactory()).createConfigBuilder();
+ will(returnValue(mockConfigBuilder));
+ }});
+
+ assertSame(mockConfigBuilder, factory.buildConfig());
+ }
+
+ public static final class ClassLoadableMockStatsManagerFactory
implements StatsManagerFactory {
+ @Override
+ public StatsManager createManager(String namespace) {
+ return null;
+ }
+ }
+}
=======================================
--- /dev/null
+++ /stajistics-core/src/test/java/org/stajistics/StatsKeyUtilTest.java Sun
Jul 31 22:38:26 2011
@@ -0,0 +1,62 @@
+package org.stajistics;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.junit.Test;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class StatsKeyUtilTest extends AbstractStajisticsTestCase {
+
+ @Test
+ public void testParentKeyName() {
+ assertEquals("a", StatsKeyUtil.parentKeyName("a.b"));
+ assertEquals("a.b", StatsKeyUtil.parentKeyName("a.b.c"));
+ assertEquals("aa", StatsKeyUtil.parentKeyName("aa.bb"));
+ assertEquals("aa.bb", StatsKeyUtil.parentKeyName("aa.bb.cc"));
+ }
+
+ @Test
+ public void testKeyNameHierarchyAscendingWithNoHierarchy() {
+ List<String> h = StatsKeyUtil.keyNameHierarchy("a", true);
+
+ assertEquals(1, h.size());
+ assertEquals("a", h.get(0));
+ }
+
+ @Test
+ public void testKeyNameHierarchyAscending() {
+ List<String> h = StatsKeyUtil.keyNameHierarchy("a.b.c.d", true);
+
+ assertEquals(4, h.size());
+ assertEquals("a", h.get(0));
+ assertEquals("a.b", h.get(1));
+ assertEquals("a.b.c", h.get(2));
+ assertEquals("a.b.c.d", h.get(3));
+ }
+
+ @Test
+ public void testKeyNameHierarchyDescendingWithNoHierarchy() {
+ List<String> h = StatsKeyUtil.keyNameHierarchy("a", false);
+
+ assertEquals(1, h.size());
+ assertEquals("a", h.get(0));
+ }
+
+ @Test
+ public void testKeyNameHierarchyDescending() {
+ List<String> h = StatsKeyUtil.keyNameHierarchy("a.b.c.d", false);
+
+ assertEquals(4, h.size());
+ assertEquals("a.b.c.d", h.get(0));
+ assertEquals("a.b.c", h.get(1));
+ assertEquals("a.b", h.get(2));
+ assertEquals("a", h.get(3));
+ }
+
+}
=======================================
--- /dev/null
+++ /stajistics-core/src/test/java/org/stajistics/StatsTest.java Sun Jul 31
22:38:26 2011
@@ -0,0 +1,51 @@
+package org.stajistics;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import
org.stajistics.DefaultStatsFactoryTest.ClassLoadableMockStatsManagerFactory;
+import org.stajistics.bootstrap.StatsManagerFactory;
+
+/**
+ *
+ *
+ * @author The Stajistics Project
+ */
+public class StatsTest extends AbstractStajisticsTestCase {
+
+ @Test
+ public void testLoadStatsManagerFactoryFromProperties() throws
Exception {
+ try {
+ System.getProperties()
+ .setProperty(StatsManagerFactory.class.getName(),
+
ClassLoadableMockStatsManagerFactory.class.getName());
+
+ StatsManagerFactory managerFactory =
Stats.loadStatsManagerFactoryFromProperties();
+
+ assertNotNull(managerFactory);
+ assertInstanceOf(ClassLoadableMockStatsManagerFactory.class,
managerFactory);
+
+ } finally {
+ System.getProperties()
+ .remove(StatsManagerFactory.class.getName());
+ }
+ }
+
+ @Test(expected = ClassNotFoundException.class)
+ public void testLoadInvalidStatsManagerFactoryFromProperties() throws
Exception {
+ try {
+ System.getProperties()
+ .setProperty(StatsManagerFactory.class.getName(),
+ "org.stajistics.DoesntExistAtAllInAnyWayWhatSoEverSoThereHa");
+
+ Stats.loadStatsManagerFactoryFromProperties();
+ fail("Allowed loading of invalid " +
StatsManagerFactory.class.getSimpleName() + " from properties");
+
+ } finally {
+ System.getProperties()
+ .remove(StatsManager.class.getName());
+ }
+ }
+
+}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/tracker/DefaultTrackerLocator.java
Wed Jul 6 09:42:09 2011
+++ /dev/null
@@ -1,179 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.tracker;
-
-import static org.stajistics.Util.assertNotEmpty;
-import static org.stajistics.Util.assertNotNull;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.stajistics.StatsKey;
-import org.stajistics.configuration.StatsConfig;
-import org.stajistics.configuration.StatsConfigManager;
-import org.stajistics.session.StatsSessionManager;
-import org.stajistics.tracker.incident.CompositeIncidentTracker;
-import org.stajistics.tracker.incident.IncidentTracker;
-import org.stajistics.tracker.manual.ManualTracker;
-import org.stajistics.tracker.span.CompositeSpanTracker;
-import org.stajistics.tracker.span.SpanTracker;
-
-/**
- * The default {@link TrackerLocator} implementation which locates
appropriate
- * {@link Tracker} instances using {@link StatsKey}'s associated {@link
org.stajistics.configuration.StatsConfig} and
- * {@link TrackerFactory}.
- *
- * @author The Stajistics Project
- */
-public class DefaultTrackerLocator implements TrackerLocator {
-
- private static final Logger logger =
LoggerFactory.getLogger(DefaultTrackerLocator.class);
-
- private final StatsConfigManager configManager;
- private final StatsSessionManager sessionManager;
-
- public DefaultTrackerLocator(final StatsConfigManager configManager,
- final StatsSessionManager sessionManager)
{
- assertNotNull(configManager, "configManager");
- assertNotNull(sessionManager, "sessionManager");
-
- this.configManager = configManager;
- this.sessionManager = sessionManager;
- }
-
- @Override
- public Tracker getTracker(final StatsKey key) {
- assertNotNull(key, "key");
- Tracker tracker = null;
-
- StatsConfig config = configManager.getOrCreateConfig(key);
- if (config.isEnabled()) {
- tracker = config.getTrackerFactory()
- .createTracker(key, sessionManager);
- }
-
- if (tracker == null) {
- tracker = NullTracker.getInstance();
- }
-
- return tracker;
- }
-
- @Override
- public SpanTracker getSpanTracker(StatsKey key) {
-
- Tracker tracker = getTracker(key);
-
- try {
- return (SpanTracker)tracker;
-
- } catch (ClassCastException cce) {
- logUnsuitableTrackerImpl(cce,
- "span",
- key,
- tracker.getClass(),
- SpanTracker.class);
- }
-
- return SpanTracker.FACTORY.createTracker(key, sessionManager);
- }
-
- @Override
- public SpanTracker getSpanTracker(StatsKey... keys) {
- assertNotEmpty(keys, "keys");
- if (keys.length == 1) {
- return getSpanTracker(keys[0]);
- }
-
- final SpanTracker[] trackers = new SpanTracker[keys.length];
-
- for (int i = 0; i < keys.length; i++) {
- trackers[i] = getSpanTracker(keys[i]);
- }
-
- return new CompositeSpanTracker(trackers);
- }
-
- @Override
- public IncidentTracker getIncidentTracker(final StatsKey key) {
- Tracker tracker = getTracker(key);
-
- try {
- return (IncidentTracker)tracker;
-
- } catch (ClassCastException cce) {
- logUnsuitableTrackerImpl(cce,
- "incident",
- key,
- tracker.getClass(),
- IncidentTracker.class);
- }
-
- return IncidentTracker.FACTORY.createTracker(key, sessionManager);
- }
-
- @Override
- public IncidentTracker getIncidentTracker(final StatsKey... keys) {
- assertNotEmpty(keys, "keys");
- if (keys.length == 1) {
- return getIncidentTracker(keys[0]);
- }
-
- final IncidentTracker[] trackers = new
IncidentTracker[keys.length];
-
- for (int i = 0; i < keys.length; i++) {
- trackers[i] = getIncidentTracker(keys[i]);
- }
-
- return new CompositeIncidentTracker(trackers);
- }
-
- @Override
- public ManualTracker getManualTracker(final StatsKey key) {
- Tracker tracker = getTracker(key);
-
- try {
- return (ManualTracker)tracker;
-
- } catch (ClassCastException cce) {
- logUnsuitableTrackerImpl(cce,
- "manual",
- key,
- tracker.getClass(),
- ManualTracker.class);
- }
-
- return ManualTracker.FACTORY.createTracker(key, sessionManager);
- }
-
- private void logUnsuitableTrackerImpl(final ClassCastException cce,
- final String trackerTypeName,
- final StatsKey key,
- final Class<? extends Tracker>
configuredTrackerClass,
- final Class<? extends Tracker>
fallbackTrackerClass) {
- logger.warn("The configured tracker is not suitable for {}
tracking. " +
- "Please check your configuration. " +
- "Falling back on: {}. " +
- "Key: {}. " +
- "Configured tracker: {}.",
- new Object[] {
- trackerTypeName,
- fallbackTrackerClass.getName(),
- key,
- configuredTrackerClass.getName()
- });
-
- logger.debug("Unsuitable tracker implementation", cce);
- }
-}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/tracker/NullTrackerLocator.java
Thu Mar 11 16:56:59 2010
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.tracker;
-
-import org.stajistics.StatsKey;
-import org.stajistics.tracker.incident.IncidentTracker;
-import org.stajistics.tracker.manual.ManualTracker;
-import org.stajistics.tracker.span.SpanTracker;
-
-/**
- * A singleton {@link TrackerLocator} implementation that returns a {@link
NullTracker}
- * instance from all methods.
- *
- * @author The Stajistics Project
- */
-public class NullTrackerLocator implements TrackerLocator {
-
- private static NullTrackerLocator INSTANCE = new NullTrackerLocator();
-
- private NullTrackerLocator() {}
-
- public static NullTrackerLocator getInstance() {
- return INSTANCE;
- }
-
- @Override
- public Tracker getTracker(StatsKey key) {
- return NullTracker.getInstance();
- }
-
- @Override
- public SpanTracker getSpanTracker(StatsKey key) {
- return NullTracker.getInstance();
- }
-
- @Override
- public SpanTracker getSpanTracker(StatsKey... keys) {
- return NullTracker.getInstance();
- }
-
- @Override
- public IncidentTracker getIncidentTracker(StatsKey key) {
- return NullTracker.getInstance();
- }
-
- @Override
- public IncidentTracker getIncidentTracker(StatsKey... keys) {
- return NullTracker.getInstance();
- }
-
- @Override
- public ManualTracker getManualTracker(StatsKey key) {
- return NullTracker.getInstance();
- }
-
-}
=======================================
---
/stajistics-core/src/main/java/org/stajistics/tracker/TrackerLocator.java
Mon Jun 20 15:36:53 2011
+++ /dev/null
@@ -1,99 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.tracker;
-
-import java.io.Serializable;
-
-import org.stajistics.StatsKey;
-import org.stajistics.tracker.incident.CompositeIncidentTracker;
-import org.stajistics.tracker.incident.IncidentTracker;
-import org.stajistics.tracker.manual.ManualTracker;
-import org.stajistics.tracker.span.CompositeSpanTracker;
-import org.stajistics.tracker.span.SpanTracker;
-
-/**
- * Provides access to various types of Tracker instances that are
associated with
- * given {@link StatsKey}s.
- *
- * @author The Stajistics Project
- */
-public interface TrackerLocator extends Serializable {
-
- /**
- * Obtain a {@link Tracker} for the given <tt>key</tt> that can be
- * used to collect statistics.
- *
- * @param key The {@link StatsKey} for which to return a tracker.
- * @return A {@link Tracker}. Never <tt>null</tt>.
- * @throws NullPointerException if <tt>key</tt> is <tt>null</tt>.
- */
- Tracker getTracker(StatsKey key);
-
- /**
- * Obtain a {@link SpanTracker} for the given <tt>key</tt> that can be
- * used to collect statistics. Regardless of the given <tt>key</tt>'s
configured
- * {@link TrackerFactory}, a SpanTracker instance is returned.
- *
- * @param key The {@link StatsKey} for which to return a tracker.
- * @return A {@link SpanTracker}. Never <tt>null</tt>.
- * @throws NullPointerException if <tt>key</tt> is <tt>null</tt>.
- */
- SpanTracker getSpanTracker(StatsKey key);
-
- /**
- * Obtain a {@link SpanTracker} for the given set of <tt>keys</tt>
that can be used to
- * collect statistics. A {@link SpanTracker} is obtained for each key
in <tt>keys</tt>
- * and all are combined in a {@link CompositeSpanTracker} instance.
- *
- * @param keys The {@link StatsKey}s for which to return a tracker.
- * @return A {@link Tracker}, never <tt>null</tt>.
- *
- * @see CompositeSpanTracker
- */
- SpanTracker getSpanTracker(StatsKey... keys);
-
- /**
- * Obtain an {@link IncidentTracker} for the given <tt>key</tt> that
can be used to
- * report an incident of an event. Regardless of the given
<tt>key</tt>'s configured
- * {@link TrackerFactory}, a IncidentTracker instance is returned.
- *
- * @param key The {@link StatsKey} for which to return a manual
tracker.
- * @return A {@link IncidentTracker}, never <tt>null</tt>.
- */
- IncidentTracker getIncidentTracker(StatsKey key);
-
- /**
- * Obtain an {@link IncidentTracker} for the given set of
<tt>keys</tt> that can be used to
- * report an incident of an event. An {@link IncidentTracker} is
obtained for each key in
- * <tt>keys</tt> and all are combined in an {@link
CompositeIncidentTracker} instance.
- *
- * @param keys The {@link StatsKey}s for which to return a tracker.
- * @return An {@link IncidentTracker}, never <tt>null</tt>.
- *
- * @see CompositeIncidentTracker
- */
- IncidentTracker getIncidentTracker(StatsKey... keys);
-
- /**
- * Obtain a {@link ManualTracker} for the given <tt>key</tt> that can
be used to
- * report manually collected data. Regardless of the given
<tt>key</tt>'s configured
- * {@link TrackerFactory}, a ManualTracker instance is returned.
- *
- * @param key The {@link StatsKey} for which to return a manual
tracker.
- * @return A {@link ManualTracker}, never <tt>null</tt>.
- */
- ManualTracker getManualTracker(StatsKey key);
-
-}
=======================================
--- /stajistics-core/src/test/java/org/stajistics/StatsFactoryTest.java Tue
Jul 5 10:11:22 2011
+++ /dev/null
@@ -1,309 +0,0 @@
-package org.stajistics;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.fail;
-
-import org.jmock.Expectations;
-import org.junit.Before;
-import org.junit.Test;
-import org.stajistics.bootstrap.StatsManagerFactory;
-import org.stajistics.configuration.StatsConfigBuilder;
-import org.stajistics.configuration.StatsConfigBuilderFactory;
-import org.stajistics.tracker.TrackerLocator;
-import org.stajistics.tracker.incident.IncidentTracker;
-import org.stajistics.tracker.manual.ManualTracker;
-import org.stajistics.tracker.span.SpanTracker;
-
-/**
- * @author The Stajistics Project
- */
-public class StatsFactoryTest extends AbstractStajisticsTestCase {
-
- private StatsFactory factory;
-
- private StatsManager mockManager;
- private TrackerLocator mockTrackerLocator;
- private StatsKey mockKey;
-
- @Before
- public void setUp() {
- mockManager = mockery.mock(StatsManager.class);
- mockTrackerLocator = mockery.mock(TrackerLocator.class);
- mockKey = mockery.mock(StatsKey.class);
-
- mockery.checking(new Expectations() {{
- allowing(mockManager).getTrackerLocator();
- will(returnValue(mockTrackerLocator));
- }});
-
- factory = new StatsFactory(mockManager);
- }
-
- @Test
- public void testLoadStatsManagerFactoryFromProperties() throws
Exception {
- try {
- System.getProperties()
- .setProperty(StatsManagerFactory.class.getName(),
-
ClassLoadableMockStatsManagerFactory.class.getName());
-
- StatsManagerFactory managerFactory =
StatsFactory.loadStatsManagerFactoryFromProperties();
-
- assertNotNull(managerFactory);
- assertInstanceOf(ClassLoadableMockStatsManagerFactory.class,
managerFactory);
-
- } finally {
- System.getProperties()
- .remove(StatsManagerFactory.class.getName());
- }
- }
-
- @Test(expected = ClassNotFoundException.class)
- public void testLoadInvalidStatsManagerFactoryFromProperties() throws
Exception {
- try {
- System.getProperties()
- .setProperty(StatsManagerFactory.class.getName(),
- "org.stajistics.DoesntExistAtAllInAnyWayWhatSoEverSoThereHa");
-
- StatsFactory.loadStatsManagerFactoryFromProperties();
- fail("Allowed loading of invalid " +
StatsManagerFactory.class.getSimpleName() + " from properties");
-
- } finally {
- System.getProperties()
- .remove(StatsManager.class.getName());
- }
- }
-
- @Test
- public void testConstructWithNullManager() {
- try {
- new StatsFactory(null);
- fail("Allowed construction of " +
StatsFactory.class.getSimpleName() + " with null statsManager");
- } catch (NullPointerException npe) {
- assertEquals("statsManager", npe.getMessage());
- }
- }
-
- @Test
- public void testGetManager() {
- assertSame(mockManager, factory.getManager());
- }
-
-
-
- @Test
- public void testStartWithKeyName() {
- final String keyName = "test.name";
- final SpanTracker mockTracker = mockery.mock(SpanTracker.class);
-
- final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
-
- mockery.checking(new Expectations() {{
- one(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- one(mockKeyFactory).createKey(keyName);
will(returnValue(mockKey));
-
one(mockTrackerLocator).getSpanTracker(with(any(StatsKey.class)));
will(returnValue(mockTracker));
- one(mockTracker).track(); will(returnValue(mockTracker));
- }});
-
- assertEquals(mockTracker, factory.track(keyName));
- }
-
- @Test
- public void testStartWithStatsKey() {
- final SpanTracker mockTracker = mockery.mock(SpanTracker.class);
-
- mockery.checking(new Expectations() {{
- one(mockTrackerLocator).getSpanTracker(with(mockKey));
will(returnValue(mockTracker));
- one(mockTracker).track(); will(returnValue(mockTracker));
- }});
-
- assertEquals(mockTracker, factory.track(mockKey));
- }
-
- @Test
- public void testSpanTrackWithStatsKeys() {
- final SpanTracker mockTracker = mockery.mock(SpanTracker.class);
- final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
-
- mockery.checking(new Expectations() {{
- one(mockTrackerLocator).getSpanTracker(with(new StatsKey[] {
mockKey, mockKey2 }));
- will(returnValue(mockTracker));
- one(mockTracker).track(); will(returnValue(mockTracker));
- }});
-
- assertEquals(mockTracker, factory.track(mockKey, mockKey2));
- }
-
- @Test
- public void testIncidentWithKeyName() {
- final String keyName = "test.name";
- final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class);
-
- final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
-
- mockery.checking(new Expectations() {{
- one(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- one(mockKeyFactory).createKey(keyName);
will(returnValue(mockKey));
- one(mockTrackerLocator).getIncidentTracker(with(mockKey));
will(returnValue(mockTracker));
- one(mockTracker).incident();
- }});
-
- factory.incident(keyName);
- }
-
- @Test
- public void testIncidentWithStatsKey() {
- final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class);
-
- mockery.checking(new Expectations() {{
- one(mockTrackerLocator).getIncidentTracker(with(mockKey));
will(returnValue(mockTracker));
- one(mockTracker).incident(); will(returnValue(mockTracker));
- }});
-
- factory.incident(mockKey);
- }
-
- @Test
- public void testIncidentWithStatsKeys() {
- final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class);
-
- final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
-
- mockery.checking(new Expectations() {{
- one(mockTrackerLocator).getIncidentTracker(with(new StatsKey[]
{ mockKey, mockKey2 }));
- will(returnValue(mockTracker));
- one(mockTracker).incident(); will(returnValue(mockTracker));
- }});
-
- factory.incident(mockKey, mockKey2);
- }
-
- @Test
- public void testFailureWithKeyName() {
-
- TestUtil.buildStatsKeyExpectations(mockery, mockKey, "test");
-
- final String keyName = "test.name";
- final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class);
-
- final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
-
- final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
- final StatsKeyBuilder mockKeyBuilder =
mockery.mock(StatsKeyBuilder.class);
-
- final Exception e = new Exception();
-
- mockery.checking(new Expectations() {{
- one(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- one(mockKeyFactory).createKey(keyName);
will(returnValue(mockKey));
- one(mockKey).buildCopy(); will(returnValue(mockKeyBuilder));
- one(mockKeyBuilder).withNameSuffix("exception");
will(returnValue(mockKeyBuilder));
- one(mockKeyBuilder).withAttribute("threw",
e.getClass().getName()); will(returnValue(mockKeyBuilder));
- one(mockKeyBuilder).newKey(); will(returnValue(mockKey2));
- one(mockTrackerLocator).getIncidentTracker(mockKey2);
will(returnValue(mockTracker));
- one(mockTracker).incident();
- }});
-
- factory.failure(e, keyName);
- }
-
- @Test
- public void testFailureWithStatsKey() {
-
- TestUtil.buildStatsKeyExpectations(mockery, mockKey, "test");
-
- final IncidentTracker mockTracker =
mockery.mock(IncidentTracker.class);
-
- final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
- final StatsKeyBuilder mockKeyBuilder =
mockery.mock(StatsKeyBuilder.class);
-
- final Exception e = new Exception();
-
- mockery.checking(new Expectations() {{
- one(mockKey).buildCopy(); will(returnValue(mockKeyBuilder));
- one(mockKeyBuilder).withNameSuffix("exception");
will(returnValue(mockKeyBuilder));
- one(mockKeyBuilder).withAttribute("threw",
e.getClass().getName()); will(returnValue(mockKeyBuilder));
- one(mockKeyBuilder).newKey(); will(returnValue(mockKey2));
- one(mockTrackerLocator).getIncidentTracker(mockKey2);
will(returnValue(mockTracker));
- one(mockTracker).incident();
- }});
-
- factory.failure(e, mockKey);
- }
-
- @Test
- public void testManualWithKeyName() {
- final String keyName = "test.name";
- final ManualTracker mockManualTracker =
mockery.mock(ManualTracker.class);
-
- final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
-
- mockery.checking(new Expectations() {{
- one(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- one(mockKeyFactory).createKey(keyName);
will(returnValue(mockKey));
-
one(mockTrackerLocator).getManualTracker(with(any(StatsKey.class)));
will(returnValue(mockManualTracker));
- }});
-
- assertEquals(mockManualTracker, factory.getManualTracker(keyName));
- }
-
- @Test
- public void testManualWithStatsKey() {
-
- final ManualTracker mockManualTracker =
mockery.mock(ManualTracker.class);
-
- mockery.checking(new Expectations() {{
- one(mockTrackerLocator).getManualTracker(with(mockKey));
will(returnValue(mockManualTracker));
- }});
-
- assertSame(mockManualTracker, factory.getManualTracker(mockKey));
- }
-
- @Test
- public void testNewKey() {
- final String keyName = "test";
- final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
-
- mockery.checking(new Expectations() {{
- one(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- one(mockKeyFactory).createKey(with(keyName));
will(returnValue(mockKey));
- }});
-
- assertSame(mockKey, factory.newKey(keyName));
- }
-
- @Test
- public void testBuildKey() {
- final String keyName = "test";
- final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
- final StatsKeyBuilder mockKeyBuilder =
mockery.mock(StatsKeyBuilder.class);
-
- mockery.checking(new Expectations() {{
- one(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- one(mockKeyFactory).createKeyBuilder(with(keyName));
will(returnValue(mockKeyBuilder));
- }});
-
- assertSame(mockKeyBuilder, factory.buildKey(keyName));
- }
-
- @Test
- public void testBuildConfig() {
- final StatsConfigBuilderFactory mockConfigBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);
- final StatsConfigBuilder mockConfigBuilder =
mockery.mock(StatsConfigBuilder.class);
-
- mockery.checking(new Expectations() {{
- one(mockManager).getConfigBuilderFactory();
will(returnValue(mockConfigBuilderFactory));
- one(mockConfigBuilderFactory).createConfigBuilder();
will(returnValue(mockConfigBuilder));
- }});
-
- assertSame(mockConfigBuilder, factory.buildConfig());
- }
-
- public static final class ClassLoadableMockStatsManagerFactory
implements StatsManagerFactory {
- @Override
- public StatsManager createManager(String namespace) {
- return null;
- }
- }
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/tracker/DefaultTrackerLocatorTest.java
Mon Jun 20 15:36:53 2011
+++ /dev/null
@@ -1,376 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.tracker;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import java.util.Iterator;
-
-import org.jmock.Expectations;
-import org.junit.Before;
-import org.junit.Test;
-import org.stajistics.AbstractStajisticsTestCase;
-import org.stajistics.StatsKey;
-import org.stajistics.TestUtil;
-import org.stajistics.configuration.StatsConfig;
-import org.stajistics.configuration.StatsConfigManager;
-import org.stajistics.session.StatsSession;
-import org.stajistics.session.StatsSessionManager;
-import org.stajistics.tracker.incident.IncidentTracker;
-import org.stajistics.tracker.manual.ManualTracker;
-import org.stajistics.tracker.span.SpanTracker;
-
-/**
- *
- *
- *
- * @author The Stajistics Project
- */
-public class DefaultTrackerLocatorTest extends AbstractStajisticsTestCase {
-
- private StatsConfigManager mockConfigManager;
- private StatsSessionManager mockSessionManager;
-
- private StatsKey mockKey;
- private StatsSession mockSession;
- private StatsConfig mockConfig;
- private TrackerFactory<?> mockTrackerFactory;
- private Tracker mockTracker;
-
- private TrackerLocator trackerLocator;
-
- @Before
- public void setUp() {
- mockConfigManager = mockery.mock(StatsConfigManager.class);
- mockSessionManager = mockery.mock(StatsSessionManager.class);
-
- mockKey = mockery.mock(StatsKey.class);
- TestUtil.buildStatsKeyExpectations(mockery, mockKey, "test");
-
- mockConfig = mockery.mock(StatsConfig.class);
- mockSession = mockery.mock(StatsSession.class);
- mockTrackerFactory = mockery.mock(TrackerFactory.class);
-
- mockTracker = mockery.mock(Tracker.class);
-
- trackerLocator = new DefaultTrackerLocator(mockConfigManager,
mockSessionManager);
- }
-
- protected void buildExpectations(final boolean configEnabled,
- final Tracker returnMockTracker) {
- mockery.checking(new Expectations() {{
-
allowing(mockSessionManager).getOrCreateSession(with(mockKey));
will(returnValue(mockSession));
- allowing(mockConfigManager).getOrCreateConfig(with(mockKey));
will(returnValue(mockConfig));
- allowing(mockConfig).isEnabled();
will(returnValue(configEnabled));
- allowing(mockConfig).getTrackerFactory();
will(returnValue(mockTrackerFactory));
- allowing(mockTrackerFactory).createTracker(with(mockKey),
-
with(mockSessionManager));
- will(returnValue(returnMockTracker));
- }});
- }
-
- @Test
- public void testConstructWithNullConfigManager() {
- try {
- new DefaultTrackerLocator(null, mockSessionManager);
- fail();
- } catch (NullPointerException npe) {
- assertEquals("configManager", npe.getMessage());
- }
- }
-
- @Test
- public void testConstructWithNullSessionManager() {
- try {
- new DefaultTrackerLocator(mockConfigManager, null);
- fail();
- } catch (NullPointerException npe) {
- assertEquals("sessionManager", npe.getMessage());
- }
- }
-
- /* STATS TRACKER */
-
- @Test
- public void testGetTracker() {
- buildExpectations(true, mockTracker);
-
- Tracker tracker = trackerLocator.getTracker(mockKey);
-
- assertNotNull(tracker);
- assertSame(mockTracker, tracker);
- }
-
- @Test
- public void testGetTrackerWithNullKey() {
- try {
- trackerLocator.getTracker(null);
- fail("Allowed getTracker with null StatsKey");
-
- } catch (NullPointerException npe) {
- assertEquals("key", npe.getMessage());
- }
- }
-
- @Test
- public void testGetTrackerWhenConfigDisabled() {
- buildExpectations(false, mockTracker);
-
- assertEquals(NullTracker.getInstance(),
trackerLocator.getTracker(mockKey));
- }
-
- /* SPAN TRACKER */
-
- @Test
- public void testGetSpanTracker() {
- SpanTracker mockSpanTracker = mockery.mock(SpanTracker.class);
- buildExpectations(true, mockSpanTracker);
-
- SpanTracker tracker = trackerLocator.getSpanTracker(mockKey);
-
- assertNotNull(tracker);
- assertEquals(mockSpanTracker, tracker);
- }
-
- @Test
- public void testGetSpanTrackerWithNullKey() {
- try {
- trackerLocator.getSpanTracker((StatsKey)null);
- fail("Allowed getSpanTracker with null StatsKey");
-
- } catch (NullPointerException npe) {
- assertEquals("key", npe.getMessage());
- }
- }
-
- @Test
- public void testGetSpanTrackerWhenConfigDisabled() {
- buildExpectations(false, mockTracker);
-
- assertEquals(NullTracker.getInstance(),
trackerLocator.getSpanTracker(mockKey));
- }
-
- @Test
- public void testGetSpanTrackerWithInvalidConfig() {
- buildExpectations(true, mockTracker);
-
- SpanTracker tracker = trackerLocator.getSpanTracker(mockKey);
- SpanTracker expectedTracker =
SpanTracker.FACTORY.createTracker(mockKey, mockSessionManager);
-
- assertNotNull(tracker);
- assertEquals(expectedTracker.getClass(), tracker.getClass());
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testGetSpanTrackerWithSizeZeroArray() {
- trackerLocator.getSpanTracker(new StatsKey[] {});
- }
-
- @Test
- public void testGetSpanTrackerWithSizeOneKeyArray() {
- buildExpectations(true, mockTracker);
-
- Tracker tracker = trackerLocator.getSpanTracker(new StatsKey[] {
mockKey });
- SpanTracker expectedTracker =
SpanTracker.FACTORY.createTracker(mockKey, mockSessionManager);
-
- assertNotNull(tracker);
- assertFalse(tracker instanceof CompositeTracker<?>);
- assertEquals(expectedTracker.getClass(), tracker.getClass());
- }
-
- @Test
- @SuppressWarnings("unchecked")
- public void testGetSpanTrackerWithSizeTwoKeyArray() {
- SpanTracker mockSpanTracker = mockery.mock(SpanTracker.class);
- buildExpectations(true, mockSpanTracker);
-
- final StatsKey mockKey2 =
mockery.mock(StatsKey.class, "StatsKey2");
- TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "test2");
-
- final StatsSession mockSession2 =
mockery.mock(StatsSession.class, "StatsSession2");
- final StatsConfig mockConfig2 =
mockery.mock(StatsConfig.class, "StatsConfig2");
- final TrackerFactory<SpanTracker> mockTrackerFactory2 =
- mockery.mock(TrackerFactory.class, "StatsTrackerFactory2");
-
- final SpanTracker mockSpanTracker2 =
mockery.mock(SpanTracker.class, "SpanTracker2");
-
- mockery.checking(new Expectations() {{
-
allowing(mockSessionManager).getOrCreateSession(with(mockKey2));
will(returnValue(mockSession2));
- allowing(mockConfigManager).getOrCreateConfig(with(mockKey2));
will(returnValue(mockConfig2));
- allowing(mockConfig2).isEnabled(); will(returnValue(true));
- allowing(mockConfig2).getTrackerFactory();
will(returnValue(mockTrackerFactory2));
- allowing(mockTrackerFactory2).createTracker(with(mockKey2),
-
with(mockSessionManager));
- will(returnValue(mockSpanTracker2));
- }});
-
- Tracker tracker = trackerLocator.getSpanTracker(new StatsKey[] {
mockKey, mockKey2 });
-
- assertNotNull(tracker);
- assertTrue(tracker instanceof CompositeTracker<?>);
-
- CompositeTracker<?> cTracker = (CompositeTracker<?>)tracker;
- assertEquals(2, cTracker.composites().size());
-
- Iterator<?> itr = cTracker.composites().iterator();
- assertSame(mockSpanTracker, itr.next());
- assertSame(mockSpanTracker2, itr.next());
- }
-
- /* INCIDENT TRACKER */
-
- @Test
- public void testGetIncidentTracker() {
- IncidentTracker mockIncidentTracker =
mockery.mock(IncidentTracker.class);
- buildExpectations(true, mockIncidentTracker);
-
- IncidentTracker tracker =
trackerLocator.getIncidentTracker(mockKey);
-
- assertNotNull(tracker);
- assertEquals(mockIncidentTracker, tracker);
- }
-
- @Test
- public void testGetIncidentTrackerWithNullKey() {
- try {
- trackerLocator.getIncidentTracker((StatsKey)null);
- fail("Allowed getIncidentTracker with null StatsKey");
-
- } catch (NullPointerException npe) {
- assertEquals("key", npe.getMessage());
- }
- }
-
- @Test
- public void testGetIncidentTrackerWhenConfigDisabled() {
- buildExpectations(false, mockTracker);
-
- assertEquals(NullTracker.getInstance(),
trackerLocator.getIncidentTracker(mockKey));
- }
-
- @Test
- public void testGetIncidentTrackerWithInvalidConfig() {
- buildExpectations(true, mockTracker);
-
- IncidentTracker tracker =
trackerLocator.getIncidentTracker(mockKey);
- IncidentTracker expectedTracker =
IncidentTracker.FACTORY.createTracker(mockKey, mockSessionManager);
-
- assertNotNull(tracker);
- assertEquals(expectedTracker.getClass(), tracker.getClass());
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testGetIncidentTrackerWithSizeZeroArray() {
- trackerLocator.getIncidentTracker(new StatsKey[] {});
- }
-
- @Test
- public void testGetIncidentTrackerWithSizeOneKeyArray() {
- buildExpectations(true, mockTracker);
-
- IncidentTracker tracker = trackerLocator.getIncidentTracker(new
StatsKey[] { mockKey });
- IncidentTracker expectedTracker =
IncidentTracker.FACTORY.createTracker(mockKey, mockSessionManager);
-
- assertNotNull(tracker);
- assertFalse(tracker instanceof CompositeTracker<?>);
- assertEquals(expectedTracker.getClass(), tracker.getClass());
- }
-
- @Test
- @SuppressWarnings("unchecked")
- public void testGetIncidentTrackerWithSizeTwoKeyArray() {
- IncidentTracker mockIncidentTracker =
mockery.mock(IncidentTracker.class);
- buildExpectations(true, mockIncidentTracker);
-
- final StatsKey mockKey2 =
mockery.mock(StatsKey.class, "StatsKey2");
- TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "test2");
-
- final StatsSession mockSession2 =
mockery.mock(StatsSession.class, "StatsSession2");
- final StatsConfig mockConfig2 =
mockery.mock(StatsConfig.class, "StatsConfig2");
- final TrackerFactory<IncidentTracker> mockTrackerFactory2 =
- mockery.mock(TrackerFactory.class, "StatsTrackerFactory2");
-
- final IncidentTracker mockIncidentTracker2 =
mockery.mock(IncidentTracker.class, "IncidentTracker2");
-
- mockery.checking(new Expectations() {{
-
allowing(mockSessionManager).getOrCreateSession(with(mockKey2));
will(returnValue(mockSession2));
- allowing(mockConfigManager).getOrCreateConfig(with(mockKey2));
will(returnValue(mockConfig2));
- allowing(mockConfig2).isEnabled(); will(returnValue(true));
- allowing(mockConfig2).getTrackerFactory();
will(returnValue(mockTrackerFactory2));
- allowing(mockTrackerFactory2).createTracker(with(mockKey2),
-
with(mockSessionManager));
- will(returnValue(mockIncidentTracker2));
- }});
-
- Tracker tracker = trackerLocator.getIncidentTracker(new StatsKey[]
{ mockKey, mockKey2 });
-
- assertNotNull(tracker);
- assertTrue(tracker instanceof CompositeTracker<?>);
-
- CompositeTracker<?> cTracker = (CompositeTracker<?>)tracker;
- assertEquals(2, cTracker.composites().size());
-
- Iterator<?> itr = cTracker.composites().iterator();
- assertSame(mockIncidentTracker, itr.next());
- assertSame(mockIncidentTracker2, itr.next());
- }
-
- /* MANUAL TRACKER */
-
- @Test
- public void testGetManualTracker() {
- ManualTracker mockManualTracker =
mockery.mock(ManualTracker.class);
- buildExpectations(true, mockManualTracker);
-
- ManualTracker tracker = trackerLocator.getManualTracker(mockKey);
-
- assertNotNull(tracker);
- assertEquals(mockManualTracker, tracker);
- }
-
- @Test
- public void testGetManualTrackerWithNullKey() {
- try {
- trackerLocator.getManualTracker(null);
- fail("Allowed getManualTracker with null StatsKey");
-
- } catch (NullPointerException npe) {
- assertEquals("key", npe.getMessage());
- }
- }
-
- @Test
- public void testGetManualTrackerWhenConfigDisabled() {
- buildExpectations(false, mockTracker);
-
- assertEquals(NullTracker.getInstance(),
trackerLocator.getManualTracker(mockKey));
- }
-
- @Test
- public void testGetManualTrackerWithInvalidConfig() {
- buildExpectations(true, mockTracker);
-
- ManualTracker tracker = trackerLocator.getManualTracker(mockKey);
- ManualTracker expectedTracker =
ManualTracker.FACTORY.createTracker(mockKey, mockSessionManager);
-
- assertNotNull(tracker);
- assertEquals(expectedTracker.getClass(), tracker.getClass());
- }
-}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/tracker/NullTrackerLocatorTest.java
Mon Jun 20 15:36:53 2011
+++ /dev/null
@@ -1,76 +0,0 @@
-/* Copyright 2009 - 2010 The Stajistics Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.stajistics.tracker;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.stajistics.AbstractStajisticsTestCase;
-import org.stajistics.StatsKey;
-
-/**
- *
- *
- *
- * @author The Stajistics Project
- */
-public class NullTrackerLocatorTest extends AbstractStajisticsTestCase {
-
- private final TrackerLocator ntl = NullTrackerLocator.getInstance();
-
- private StatsKey mockKey;
-
- @Before
- public void setUp() {
- mockKey = mockery.mock(StatsKey.class);
- }
-
- @Test
- public void testGetTracker() {
- assertEquals(NullTracker.getInstance(),
- ntl.getTracker(mockKey));
- }
-
- @Test
- public void testGetSpanTrackerWithKey() {
- assertEquals(NullTracker.getInstance(),
- ntl.getSpanTracker(mockKey));
- }
-
- @Test
- public void testGetSpanTrackerWithKeys() {
- assertEquals(NullTracker.getInstance(),
- ntl.getSpanTracker(new StatsKey[] { mockKey }));
- }
-
- @Test
- public void testGetIncidentTrackerWithKey() {
- assertEquals(NullTracker.getInstance(),
- ntl.getIncidentTracker(mockKey));
- }
-
- @Test
- public void testGetIncidentTrackerWithKeys() {
- assertEquals(NullTracker.getInstance(),
- ntl.getIncidentTracker(new StatsKey[] { mockKey }));
- }
-
- @Test
- public void testGetManualTracker() {
- assertEquals(NullTracker.getInstance(),
- ntl.getManualTracker(mockKey));
- }
-}
=======================================
--- /pom.xml Sun Jul 10 14:49:07 2011
+++ /pom.xml Sun Jul 31 22:38:26 2011
@@ -94,8 +94,11 @@
<jmock-version>2.5.1</jmock-version>
<slf4j-version>1.5.10</slf4j-version>

+ <maven-site-plugin-version>3.0-beta-3</maven-site-plugin-version>
<maven-javadoc-plugin-version>2.8</maven-javadoc-plugin-version>
<maven-jxr-plugin-version>2.2</maven-jxr-plugin-version>
+
+ <site.basedir>${project.basedir}</site.basedir>
</properties>

<build>
@@ -266,11 +269,10 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
- <version>3.0-beta-3</version>
+ <version>${maven-site-plugin-version}</version>
</plugin>
</plugins>
</pluginManagement>
-
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
@@ -306,24 +308,75 @@
<build>
<plugins>
<plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- <version>${maven-javadoc-plugin-version}</version>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-source-plugin</artifactId>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-jxr-plugin</artifactId>
- <version>${maven-jxr-plugin-version}</version>
- </plugin>
- <plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
+ <version>${maven-site-plugin-version}</version>
<configuration>
-
<includeProjectDocumentation>true</includeProjectDocumentation>
+ <reportPlugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-project-info-reports-plugin</artifactId>
+ <version>2.2</version>
+ <reports>
+ <report>index</report>
+ <report>project-team</report>
+ <report>license</report>
+ <report>mailing-list</report>
+ <report>dependencies</report>
+ <report>dependency-convergence</report>
+ <report>plugin-management</report>
+ <report>cim</report>
+ <report>issue-tracking</report>
+ <report>scm</report>
+ <report>summary</report>
+ </reports>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>${maven-javadoc-plugin-version}</version>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-report-plugin</artifactId>
+ <version>2.6</version>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-source-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jxr-plugin</artifactId>
+ <version>${maven-jxr-plugin-version}</version>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>cobertura-maven-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>findbugs-maven-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>jdepend-maven-plugin</artifactId>
+ <version>2.0-beta-2</version>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>taglist-maven-plugin</artifactId>
+ <version>2.4</version>
+ <configuration>
+ <tags>
+ <tag>@fixme</tag>
+ <tag>FIXME</tag>
+ <tag>@todo</tag>
+ <tag>TODO</tag>
+ </tags>
+ </configuration>
+ </plugin>
+ </reportPlugins>
</configuration>
<executions>
<execution>
@@ -334,56 +387,33 @@
</execution>
</executions>
</plugin>
- </plugins>
- </build>
- <reporting>
- <plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-javadoc-plugin</artifactId>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-jxr-plugin</artifactId>
- </plugin>
- 
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-report-plugin</artifactId>
- <version>2.9</version>
- </plugin>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>cobertura-maven-plugin</artifactId>
- </plugin>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>findbugs-maven-plugin</artifactId>
- </plugin>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>jdepend-maven-plugin</artifactId>
- <version>2.0-beta-2</version>
- </plugin>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>taglist-maven-plugin</artifactId>
- <version>2.4</version>
- <configuration>
- <tags>
- <tag>@fixme</tag>
- <tag>FIXME</tag>
- <tag>@todo</tag>
- <tag>TODO</tag>
- </tags>
- </configuration>
+ <artifactId>maven-resources-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>copy-sitedescriptor</id>
+ 
+ <phase>pre-site</phase>
+ <goals>
+ <goal>copy-resources</goal>
+ </goals>
+ <configuration>
+ <outputDirectory>${basedir}/src/site/</outputDirectory>
+ <resources>
+ <resource>
+ <directory>${site.basedir}/src/site/</directory>
+ <includes>
+ <include>**/site.xml</include>
+ </includes>
+ </resource>
+ </resources>
+ </configuration>
+ </execution>
+ </executions>
</plugin>
</plugins>
- </reporting>
+ </build>
</profile>
<profile>
<id>sign-artifacts</id>
=======================================
--- /src/site/apt/index.apt Mon Mar 2 15:56:42 2009
+++ /src/site/apt/index.apt Sun Jul 31 22:38:26 2011
@@ -2,7 +2,7 @@

Stajistics is a free monitoring and runtime performance statistics
collection API for Java.

- This project is currently in the alpha stage. No binary releases have
been made yet.
+ This project is currently in the beta stage.

Features:

@@ -16,7 +16,7 @@

* Data persistence service (Planned)

- * Java Management eXtensions (JMX) integration (Planned)
+ * Java Management eXtensions (JMX) integration

* XML based configuration (Planned)

@@ -25,4 +25,4 @@

Requirements:

- * Java 1.5
+ * Java 1.6
=======================================
--- /src/site/site.xml Mon Mar 2 15:56:42 2009
+++ /src/site/site.xml Sun Jul 31 22:38:26 2011
@@ -12,7 +12,8 @@
<menu name="Stajistics">
<item name="Overview" href="index.html" />
</menu>
- <menu ref="modules" />
- <menu ref="reports" />
+ <menu ref="parent" inherit="top" />
+ <menu ref="modules" inherit="top" />
+ <menu ref="reports" inherit="top" />
</body>
</project>
=======================================
--- /stajistics-core/pom.xml Thu Jun 2 04:43:48 2011
+++ /stajistics-core/pom.xml Sun Jul 31 22:38:26 2011
@@ -15,4 +15,8 @@

<url>http://code.google.com/p/stajistics/source/browse/#svn/trunk/stajistics-core</url>
</scm>

+ <properties>
+ <site.basedir>${project.parent.basedir}</site.basedir>
+ </properties>
+
</project>
=======================================
--- /stajistics-core/src/main/java/org/stajistics/DefaultStatsManager.java
Wed Jul 6 11:14:38 2011
+++ /stajistics-core/src/main/java/org/stajistics/DefaultStatsManager.java
Sun Jul 31 22:38:26 2011
@@ -28,10 +28,6 @@
import org.stajistics.session.DefaultSessionManager;
import org.stajistics.session.StatsSessionManager;
import org.stajistics.task.TaskService;
-import org.stajistics.task.ThreadPoolTaskService;
-import org.stajistics.tracker.DefaultTrackerLocator;
-import org.stajistics.tracker.NullTrackerLocator;
-import org.stajistics.tracker.TrackerLocator;
import org.stajistics.util.ServiceLifeCycle;

/**
@@ -49,7 +45,6 @@
protected final StatsConfigManager configManager;
protected final StatsSessionManager sessionManager;
protected final EventManager eventManager;
- protected final TrackerLocator trackerLocator;
protected final StatsKeyFactory keyFactory;
protected final StatsConfigBuilderFactory configBuilderFactory;

@@ -71,13 +66,11 @@
final StatsConfigManager configManager,
final StatsSessionManager sessionManager,
final EventManager eventManager,
- final TrackerLocator trackerLocator,
final StatsKeyFactory keyFactory,
final StatsConfigBuilderFactory
configBuilderFactory) {
assertNotNull(configManager, "configManager");
assertNotNull(sessionManager, "sessionManager");
assertNotNull(eventManager, "eventManager");
- assertNotNull(trackerLocator, "trackerLocator");
assertNotNull(keyFactory, "keyFactory");
assertNotNull(configBuilderFactory, "configBuilderFactory");

@@ -90,7 +83,6 @@
this.keyFactory = keyFactory;
this.configManager = configManager;
this.sessionManager = sessionManager;
- this.trackerLocator = trackerLocator;
this.eventManager = eventManager;
this.configBuilderFactory = configBuilderFactory;
}
@@ -167,15 +159,6 @@
public EventManager getEventManager() {
return eventManager;
}
-
- @Override
- public TrackerLocator getTrackerLocator() {
- if (!enabled) {
- return NullTrackerLocator.getInstance();
- }
-
- return trackerLocator;
- }

@Override
public StatsKeyFactory getKeyFactory() {
@@ -219,7 +202,6 @@
protected StatsConfigManager configManager = null;
protected StatsSessionManager sessionManager = null;
protected EventManager eventManager = null;
- protected TrackerLocator trackerLocator = null;
protected StatsKeyFactory keyFactory = null;
protected StatsConfigBuilderFactory configBuilderFactory = null;
protected boolean enabled = true;
@@ -247,12 +229,6 @@
this.eventManager = eventManager;
return this;
}
-
- public Builder withTrackerLocator(final TrackerLocator
trackerLocator) {
- assertNotNull(trackerLocator, "trackerLocator");
- this.trackerLocator = trackerLocator;
- return this;
- }

public Builder withKeyFactory(final StatsKeyFactory keyFactory) {
assertNotNull(keyFactory, "keyFactory");
@@ -283,7 +259,6 @@
EventManager eventManager = this.eventManager;
StatsConfigManager configManager = this.configManager;
StatsSessionManager sessionManager = this.sessionManager;
- TrackerLocator trackerLocator = this.trackerLocator;
StatsConfigBuilderFactory configBuilderFactory =
this.configBuilderFactory;

if (keyFactory == null) {
@@ -300,10 +275,6 @@
if (sessionManager == null) {
sessionManager = new DefaultSessionManager(configManager,
eventManager);
}
-
- if (trackerLocator == null) {
- trackerLocator = new DefaultTrackerLocator(configManager,
sessionManager);
- }

if (configBuilderFactory == null) {
configBuilderFactory = new
DefaultStatsConfigBuilderFactory(configManager);
@@ -313,7 +284,6 @@

configManager,

sessionManager,

eventManager,
-
trackerLocator,

keyFactory,

configBuilderFactory);

=======================================
--- /stajistics-core/src/main/java/org/stajistics/StatsFactory.java Wed
Jul 6 09:42:09 2011
+++ /stajistics-core/src/main/java/org/stajistics/StatsFactory.java Sun Jul
31 22:38:26 2011
@@ -5,14 +5,14 @@

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.stajistics.bootstrap.DefaultStatsManagerFactory;
-import org.stajistics.bootstrap.StatsManagerFactory;
+import org.stajistics.configuration.StatsConfig;
import org.stajistics.configuration.StatsConfigBuilder;
import org.stajistics.tracker.NullTracker;
import org.stajistics.tracker.Tracker;
-import org.stajistics.tracker.TrackerLocator;
+import org.stajistics.tracker.incident.CompositeIncidentTracker;
import org.stajistics.tracker.incident.IncidentTracker;
import org.stajistics.tracker.manual.ManualTracker;
+import org.stajistics.tracker.span.CompositeSpanTracker;
import org.stajistics.tracker.span.SpanTracker;

/**
@@ -29,116 +29,9 @@
*
* @author The Stajistics Project
*/
-public class StatsFactory {
-
- private static final Logger logger =
LoggerFactory.getLogger(StatsFactory.class);
-
- protected static final String PROP_MANAGER_FACTORY =
StatsManagerFactory.class.getName();
- protected static final String PROP_AUTO_INIT_DEFAULT_MANAGER =
StatsFactory.class.getName() + ".autoInitDefaultManager";
-
- protected final StatsManager statsManager;
-
- public StatsFactory(final StatsManager statsManager) {
- assertNotNull(statsManager, "statsManager");
- this.statsManager = statsManager;
- }
-
- public static StatsFactory forClass(final Class<?> aClass) {
- assertNotNull(aClass, "aClass");
-
- final StatsManagerRegistry reg =
StatsManagerRegistry.getInstance();
- String pkg = aClass.getPackage().getName();
-
- do {
- String namespace = pkg;
- if (reg.isStatsManagerDefined(namespace)) {
- StatsManager statsManager = reg.getStatsManager(namespace);
- if (statsManager != null) {
- logger.debug("Found StatsManager at namespace '{}' for
class '{}'.", namespace, aClass);
- return new StatsFactory(statsManager);
- }
- }
-
- int i = pkg.lastIndexOf('.');
- if (i > -1) {
- pkg = pkg.substring(0, i);
- } else {
- pkg = null;
- }
- } while (pkg != null);
-
- logger.debug("No matching namespaces defined for class '{}'.
Attemping to use default namespace.", aClass);
-
- return forNamespace(StatsConstants.DEFAULT_NAMESPACE);
- }
-
- public static StatsFactory forNamespace(final String namespace) {
- assertNotNull(namespace, "namespace");
- final StatsManagerRegistry reg =
StatsManagerRegistry.getInstance();
-
- if (reg.isStatsManagerDefined(namespace)) {
- StatsManager statsManager = reg.getStatsManager(namespace);
- return new StatsFactory(statsManager);
- }
-
- // Namespace not found
-
- if (namespace.equals(StatsConstants.DEFAULT_NAMESPACE)) {
- boolean autoInitDefaultManager =
Boolean.parseBoolean(System.getProperty(PROP_AUTO_INIT_DEFAULT_MANAGER,
-
Boolean.TRUE.toString()));
- if (autoInitDefaultManager) {
- loadDefaultStatsManager();
- StatsManager statsManager = reg.getStatsManager(namespace);
- return new StatsFactory(statsManager);
- }
- }
-
- throw new StatsNamespaceNotFoundException(namespace);
- }
-
- protected static StatsManager loadDefaultStatsManager() {
-
- StatsManager manager = null;
-
- try {
- StatsManagerFactory managerFactory =
loadStatsManagerFactoryFromProperties();
- if (managerFactory != null) {
- manager =
managerFactory.createManager(StatsConstants.DEFAULT_NAMESPACE);
- if (manager == null) {
- logger.error(StatsManagerFactory.class.getSimpleName()
+ " created null " +
- StatsManager.class.getSimpleName() + ": "
+ managerFactory.getClass());
- }
- }
-
- } catch (Exception e) {
- logger.error("Failed to load " +
StatsManager.class.getSimpleName() + ": " + e.toString(), e);
- }
-
- if (manager == null) {
- manager = new
DefaultStatsManagerFactory().createManager(StatsConstants.DEFAULT_NAMESPACE);
- }
-
- return manager;
- }
-
- protected static StatsManagerFactory
loadStatsManagerFactoryFromProperties() throws Exception {
- StatsManagerFactory managerFactory = null;
-
- String managerFactoryClassName =
System.getProperty(PROP_MANAGER_FACTORY);
- if (managerFactoryClassName != null) {
- @SuppressWarnings("unchecked")
- Class<StatsManagerFactory> managerFactoryClass =
-
(Class<StatsManagerFactory>)Class.forName(managerFactoryClassName);
-
- managerFactory = managerFactoryClass.newInstance();
- }
-
- return managerFactory;
- }
-
- public StatsManager getManager() {
- return statsManager;
- }
+public interface StatsFactory {
+
+ StatsManager getManager();

/**
* Determine if statistics collection is enabled.
@@ -147,9 +40,8 @@
*
* @see StatsManager#isEnabled()
*/
- public boolean isEnabled() {
- return statsManager.isEnabled();
- }
+ boolean isEnabled();
+

/**
* Obtain a {@link SpanTracker} for the given <tt>keyName</tt> that
can be used
@@ -160,17 +52,7 @@
* @return A {@link SpanTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*/
- public SpanTracker getSpanTracker(final String keyName) {
- try {
- return statsManager.getTrackerLocator()
- .getSpanTracker(newKey(keyName));
- } catch (Exception e) {
- logger.error("Failed to obtain a " +
SpanTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullTracker.getInstance();
- }
- }
+ SpanTracker getSpanTracker(String keyName);

/**
* Obtain a {@link SpanTracker} for the given <tt>key</tt> that can be
used
@@ -180,17 +62,7 @@
* @return A {@link SpanTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*/
- public SpanTracker getSpanTracker(final StatsKey key) {
- try {
- return statsManager.getTrackerLocator()
- .getSpanTracker(key);
- } catch (Exception e) {
- logger.error("Failed to obtain a " +
SpanTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(key, e);
- return NullTracker.getInstance();
- }
- }
+ SpanTracker getSpanTracker(StatsKey key);

/**
* Obtain a {@link SpanTracker} for the given <tt>keys</tt> that can
be used
@@ -200,17 +72,7 @@
* @return A {@link SpanTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*/
- public SpanTracker getSpanTracker(final StatsKey... keys) {
- try {
- return statsManager.getTrackerLocator()
- .getSpanTracker(keys);
- } catch (Exception e) {
- logger.error("Failed to obtain a " +
SpanTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullTracker.getInstance();
- }
- }
+ SpanTracker getSpanTracker(StatsKey... keys);

/**
* A convenience method equivalent to calling:
@@ -220,21 +82,9 @@
* @return A {@link SpanTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*
- * @see TrackerLocator#getSpanTracker(StatsKey)
* @see SpanTracker#track()
*/
- public SpanTracker track(final String keyName) {
- try {
- return statsManager.getTrackerLocator()
- .getSpanTracker(newKey(keyName))
- .track();
- } catch (Exception e) {
- logger.error("Failed to obtain and invoke track on " +
SpanTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullTracker.getInstance();
- }
- }
+ SpanTracker track(String keyName);

/**
* A convenience method equivalent to calling:
@@ -244,21 +94,9 @@
* @return A {@link SpanTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*
- * @see TrackerLocator#getSpanTracker(StatsKey)
* @see SpanTracker#track()
*/
- public SpanTracker track(final StatsKey key) {
- try {
- return statsManager.getTrackerLocator()
- .getSpanTracker(key)
- .track();
- } catch (Exception e) {
- logger.error("Failed to obtain and invoke track on " +
SpanTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(key, e);
- return NullTracker.getInstance();
- }
- }
+ SpanTracker track(StatsKey key);

/**
* A convenience method equivalent to calling:
@@ -268,21 +106,9 @@
* @return A {@link SpanTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*
- * @see TrackerLocator#getSpanTracker(StatsKey...)
* @see SpanTracker#track()
*/
- public SpanTracker track(final StatsKey... keys) {
- try {
- return statsManager.getTrackerLocator()
- .getSpanTracker(keys)
- .track();
- } catch (Exception e) {
- logger.error("Failed to obtain and invoke track on " +
SpanTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullTracker.getInstance();
- }
- }
+ SpanTracker track(StatsKey... keys);

/**
* Obtain an {@link IncidentTracker} for the given <tt>keyName</tt>
that can be
@@ -292,19 +118,8 @@
* @return An {@link IncidentTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
*
- * @see TrackerLocator#getIncidentTracker(StatsKey)
*/
- public IncidentTracker getIncidentTracker(final String keyName) {
- try {
- return statsManager.getTrackerLocator()
- .getIncidentTracker(newKey(keyName));
- } catch (Exception e) {
- logger.error("Failed to obtain an " +
IncidentTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullTracker.getInstance();
- }
- }
+ IncidentTracker getIncidentTracker(String keyName);

/**
* Obtain an {@link IncidentTracker} for the given <tt>key</tt> that
can be
@@ -313,20 +128,8 @@
* @param key The {@link StatsKey} for which to return an incident
tracker.
* @return An {@link IncidentTracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
- *
- * @see TrackerLocator#getIncidentTracker(StatsKey)
*/
- public IncidentTracker getIncidentTracker(final StatsKey key) {
- try {
- return statsManager.getTrackerLocator()
- .getIncidentTracker(key);
- } catch (Exception e) {
- logger.error("Failed to obtain an " +
IncidentTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(key, e);
- return NullTracker.getInstance();
- }
- }
+ IncidentTracker getIncidentTracker(StatsKey key);

/**
* Report an incident. Equivalent to calling:
@@ -334,20 +137,9 @@
*
* @param keyName The key name for which to report an incident.
*
- * @see TrackerLocator#getIncidentTracker(StatsKey...)
* @see IncidentTracker#incident()
*/
- public void incident(final String keyName) {
- try {
- statsManager.getTrackerLocator()
- .getIncidentTracker(newKey(keyName))
- .incident();
- } catch (Exception e) {
- logger.error("Failed to obtain and invoke an " +
IncidentTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- }
- }
+ void incident(String keyName);

/**
* Report an incident. Equivalent to calling:
@@ -355,20 +147,9 @@
*
* @param key The {@link StatsKey} for which to report an incident.
*
- * @see TrackerLocator#getIncidentTracker(StatsKey...)
* @see IncidentTracker#incident()
*/
- public void incident(final StatsKey key) {
- try {
- statsManager.getTrackerLocator()
- .getIncidentTracker(key)
- .incident();
- } catch (Exception e) {
- logger.error("Failed to obtain and invoke an " +
IncidentTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(key, e);
- }
- }
+ void incident(final StatsKey key);

/**
* Report an incident. Equivalent to calling:
@@ -376,20 +157,9 @@
*
* @param keys The {@link StatsKey}s for which to report an incident.
*
- * @see TrackerLocator#getIncidentTracker(StatsKey...)
* @see IncidentTracker#incident()
*/
- public void incident(final StatsKey... keys) {
- try {
- statsManager.getTrackerLocator()
- .getIncidentTracker(keys)
- .incident();
- } catch (Exception e) {
- logger.error("Failed to obtain and invoke an " +
IncidentTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- }
- }
+ void incident(final StatsKey... keys);

/**
* Report a failure that is represented by a Throwable.
@@ -397,18 +167,8 @@
* @param failure The Throwable that represents the failure.
* @param keyName The key name for which to report an incident.
*/
- public void failure(final Throwable failure,
- final String keyName) {
- try {
- statsManager.getTrackerLocator()
- .getIncidentTracker(StatsKeyUtil.keyForFailure(newKey(keyName),
failure))
- .incident();
- } catch (Exception e) {
- logger.error("Failed to report a failure", e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- }
- }
+ void failure(final Throwable failure,
+ final String keyName);

/**
* Report a failure that is represented by a Throwable.
@@ -416,18 +176,7 @@
* @param failure The Throwable that represents the failure.
* @param key The {@link StatsKey} for which to report a failure.
*/
- public void failure(final Throwable failure,
- final StatsKey key) {
- try {
- statsManager.getTrackerLocator()
- .getIncidentTracker(StatsKeyUtil.keyForFailure(key,
failure))
- .incident();
- } catch (Exception e) {
- logger.error("Failed to report a failure", e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(key, e);
- }
- }
+ void failure(Throwable failure, StatsKey key);

/**
* Report a failure that is represented by a Throwable.
@@ -435,23 +184,7 @@
* @param keys The {@link StatsKey}s for which to report a failure.
* @param failure The Throwable that represents the failure.
*/
- public void failure(final Throwable failure,
- final StatsKey... keys) {
- try {
- assertNotEmpty(keys, "keys");
-
- final TrackerLocator trackerLocator =
statsManager.getTrackerLocator();
-
- for (StatsKey key : keys) {
-
trackerLocator.getIncidentTracker(StatsKeyUtil.keyForFailure(key, failure))
- .incident();
- }
- } catch (Exception e) {
- logger.error("Failed to report a failure", e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- }
- }
+ void failure(Throwable failure, StatsKey... keys);

/**
* Obtain a {@link ManualTracker} for the given key <tt>keyName</tt>
that can be
@@ -460,20 +193,8 @@
* @param keyName The key name for which to return a manual tracker.
* @return A {@link Tracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
- *
- * @see TrackerLocator#getManualTracker(StatsKey)
*/
- public ManualTracker getManualTracker(final String keyName) {
- try {
- return statsManager.getTrackerLocator()
- .getManualTracker(newKey(keyName));
- } catch (Exception e) {
- logger.error("Failed to obtain a " +
ManualTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullTracker.getInstance();
- }
- }
+ ManualTracker getManualTracker(String keyName);

/**
* Obtain a {@link ManualTracker} for the given <tt>key</tt> that can
be
@@ -482,20 +203,8 @@
* @param key The {@link StatsKey} for which to return a manual
tracker.
* @return A {@link Tracker} instance,
* or a {@link NullTracker} if an Exception occurred, never
<tt>null</tt>.
- *
- * @see TrackerLocator#getManualTracker(StatsKey)
*/
- public ManualTracker getManualTracker(final StatsKey key) {
- try {
- return statsManager.getTrackerLocator()
- .getManualTracker(key);
- } catch (Exception e) {
- logger.error("Failed to obtain a " +
ManualTracker.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(key, e);
- return NullTracker.getInstance();
- }
- }
+ ManualTracker getManualTracker(StatsKey key);

/**
* Create a new {@link StatsKey} from the given <tt>name</tt>.
@@ -506,17 +215,7 @@
*
* @see StatsKeyFactory#createKey(String)
*/
- public StatsKey newKey(final String name) {
- try {
- return statsManager.getKeyFactory()
- .createKey(name);
- } catch (Exception e) {
- logger.error("Failed to create a " +
StatsKey.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullStatsKey.getInstance();
- }
- }
+ StatsKey newKey(String name);

/**
* Create a new {@link StatsKeyBuilder} which can create a new {@link
StatsKey}
@@ -528,17 +227,7 @@
*
* @see StatsKeyFactory#createKeyBuilder(StatsKey)
*/
- public StatsKeyBuilder buildKey(final String name) {
- try {
- return statsManager.getKeyFactory()
- .createKeyBuilder(name);
- } catch (Exception e) {
- logger.error("Failed to create a " +
StatsKeyBuilder.class.getSimpleName(), e);
- statsManager.getUncaughtExceptionHandler()
- .uncaughtException(null, e);
- return NullStatsKeyBuilder.getInstance();
- }
- }
+ StatsKeyBuilder buildKey(String name);

/**
* Create a new {@link StatsConfigBuilder} which can assemble various
configurations.
@@ -547,9 +236,6 @@
*
* @see
org.stajistics.configuration.StatsConfigBuilderFactory#createConfigBuilder()
*/
- public StatsConfigBuilder buildConfig() {
- return statsManager.getConfigBuilderFactory()
- .createConfigBuilder();
- }
+ StatsConfigBuilder buildConfig();

}
=======================================
--- /stajistics-core/src/main/java/org/stajistics/StatsKeyUtil.java Mon Jun
20 15:36:53 2011
+++ /stajistics-core/src/main/java/org/stajistics/StatsKeyUtil.java Sun Jul
31 22:38:26 2011
@@ -14,6 +14,9 @@
*/
package org.stajistics;

+import java.util.ArrayList;
+import java.util.List;
+
/**
*
*
@@ -24,6 +27,11 @@

private StatsKeyUtil() {}

+ /**
+ * Obtain the name of the parent key of <tt>keyName</tt>, or
<tt>null</tt> if it doesn't have a parent.
+ * @param keyName
+ * @return
+ */
public static String parentKeyName(final String keyName) {
String parentKeyName = null;

@@ -34,14 +42,66 @@

return parentKeyName;
}
+
+ /**
+ * Get a list containing the key name hierarchy for the given
<tt>keyName</tt>.
+ * @param keyName
+ * @return
+ */
+ public static List<String> keyNameHierarchy(final String keyName,
boolean ascending) {
+ final List<String> result = new ArrayList<String>(8);
+
+ if (ascending) {
+ int i = -1;
+ for (;;) {
+ i =
keyName.indexOf(StatsConstants.KEY_HIERARCHY_DELIMITER, i + 1);
+ if (i == -1) {
+ result.add(keyName);
+ break;
+ }
+
+ result.add(keyName.substring(0, i));
+ }
+ } else {
+ result.add(keyName);
+
+ int i = keyName.length();
+ for (;;) {
+ i =
keyName.lastIndexOf(StatsConstants.KEY_HIERARCHY_DELIMITER, i - 1);
+ if (i == -1) {
+ break;
+ }
+
+ result.add(keyName.substring(0, i));
+ }
+ }
+
+ return result;
+ }
+
+ public static List<StatsKey> keyHierarchy(final String keyName, final
StatsKeyFactory keyFactory, final boolean ascending) {
+ final List<String> keyNameHierarchy = keyNameHierarchy(keyName,
ascending);
+ final int keyCount = keyNameHierarchy.size();
+ final List<StatsKey> result = new ArrayList<StatsKey>(keyCount);
+
+ for (int i = 0; i < keyCount; i++) {
+ result.add(keyFactory.createKey(keyNameHierarchy.get(i)));
+ }
+
+ return result;
+ }

public static StatsKey keyForFailure(final StatsKey key,
final Throwable failure) {
+ if (key == null) {
+ return NullStatsKey.getInstance();
+ }
+
+ String failureClassName = (failure == null) ? null :
failure.getClass().getName();
+
StatsKey failureKey = key.buildCopy()
.withNameSuffix("exception")
- .withAttribute("threw",
- failure.getClass()
- .getName())
+ .withAttribute("threw", failureClassName)
.newKey();
return failureKey;
}
=======================================
--- /stajistics-core/src/main/java/org/stajistics/StatsManager.java Wed
Jul 6 11:14:38 2011
+++ /stajistics-core/src/main/java/org/stajistics/StatsManager.java Sun Jul
31 22:38:26 2011
@@ -20,8 +20,6 @@
import org.stajistics.configuration.StatsConfigManager;
import org.stajistics.event.EventManager;
import org.stajistics.session.StatsSessionManager;
-import org.stajistics.task.TaskService;
-import org.stajistics.tracker.TrackerLocator;
import org.stajistics.util.ServiceLifeCycle;

/**
@@ -60,13 +58,6 @@
*/
EventManager getEventManager();

- /**
- * Get the {@link TrackerLocator}.
- *
- * @return The {@link TrackerLocator}, never <tt>null</tt>.
- */
- TrackerLocator getTrackerLocator();
-
/**
* Get the {@link StatsKeyFactory}.
*
=======================================
---
/stajistics-core/src/main/java/org/stajistics/UncaughtExceptionHandler.java
Sun Jun 12 20:45:46 2011
+++
/stajistics-core/src/main/java/org/stajistics/UncaughtExceptionHandler.java
Sun Jul 31 22:38:26 2011
@@ -9,7 +9,7 @@

/**
*
- * @param key
+ * @param key A key related to the Exception, or <tt>null</tt>.
* @param e
*/
void uncaughtException(StatsKey key, Throwable e);
=======================================
--- /stajistics-core/src/main/java/org/stajistics/aop/LifeCycleMonitor.java
Tue Jul 5 10:11:22 2011
+++ /stajistics-core/src/main/java/org/stajistics/aop/LifeCycleMonitor.java
Sun Jul 31 22:38:26 2011
@@ -21,6 +21,7 @@
import java.util.IdentityHashMap;
import java.util.Map;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
@@ -49,7 +50,7 @@

public LifeCycleMonitor(final StatsFactory factory) {
if (factory == null) {
- this.factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ this.factory =
Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
} else {
this.factory = factory;
}
@@ -139,7 +140,7 @@

public static void main(String[] args) throws Exception {

- StatsFactory factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ StatsFactory factory =
Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
LifeCycleMonitor<Object> lcm = new
LifeCycleMonitor<Object>(factory);

StatsKey key = factory.newKey("test");
=======================================
--- /stajistics-core/src/main/java/org/stajistics/aop/StatsDecorators.java
Wed Jul 6 09:42:09 2011
+++ /stajistics-core/src/main/java/org/stajistics/aop/StatsDecorators.java
Sun Jul 31 22:38:26 2011
@@ -22,6 +22,7 @@
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadFactory;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
@@ -43,7 +44,7 @@

public StatsDecorators(final StatsFactory factory) {
if (factory == null) {
- this.factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ this.factory =
Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
} else {
this.factory = factory;
}
=======================================
--- /stajistics-core/src/main/java/org/stajistics/aop/StatsProxy.java Wed
Jul 6 09:42:09 2011
+++ /stajistics-core/src/main/java/org/stajistics/aop/StatsProxy.java Sun
Jul 31 22:38:26 2011
@@ -21,9 +21,10 @@
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
-import org.stajistics.StatsKey;
import org.stajistics.StatsFactory;
+import org.stajistics.StatsKey;
import org.stajistics.tracker.span.SpanTracker;

/**
@@ -54,7 +55,7 @@
final StatsKey key,
final Object target) {
if (factory == null) {
- this.factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ this.factory =
Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
} else {
this.factory = factory;
}
@@ -151,6 +152,11 @@
public Object invoke(final Object proxy,
final Method method,
final Object[] args) throws Throwable {
+ // Handle equals specially
+ if (method.equals(EQUALS_METHOD)) {
+ return target.equals(unwrap(args[0]));
+ }
+
StatsKey methodKey = key.buildCopy()
.withAttribute(ATTR_METHOD,
getMethodString(method))
.newKey();
@@ -158,10 +164,6 @@
try {
final SpanTracker tracker = factory.track(methodKey);
try {
- if (method.equals(EQUALS_METHOD)) {
- return target.equals(unwrap(args[0]));
- }
-
return method.invoke(target, args);

} finally {
=======================================
---
/stajistics-core/src/main/java/org/stajistics/io/StatsFilterInputStream.java
Wed Jul 6 09:42:09 2011
+++
/stajistics-core/src/main/java/org/stajistics/io/StatsFilterInputStream.java
Sun Jul 31 22:38:26 2011
@@ -6,6 +6,7 @@
import java.io.IOException;
import java.io.InputStream;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
@@ -29,7 +30,7 @@
super(in);

if (factory == null) {
- factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ factory = Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
}

assertNotNull(key, "key");
=======================================
---
/stajistics-core/src/main/java/org/stajistics/io/StatsFilterOutputStream.java
Wed Jul 6 09:42:09 2011
+++
/stajistics-core/src/main/java/org/stajistics/io/StatsFilterOutputStream.java
Sun Jul 31 22:38:26 2011
@@ -6,6 +6,7 @@
import java.io.IOException;
import java.io.OutputStream;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
@@ -29,7 +30,7 @@
super(out);

if (factory == null) {
- factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ factory = Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
}

assertNotNull(key, "key");
=======================================
--- /stajistics-core/src/main/java/org/stajistics/io/StatsFilterReader.java
Wed Jul 6 09:42:09 2011
+++ /stajistics-core/src/main/java/org/stajistics/io/StatsFilterReader.java
Sun Jul 31 22:38:26 2011
@@ -7,6 +7,7 @@
import java.io.Reader;
import java.nio.CharBuffer;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
@@ -30,7 +31,7 @@
super(in);

if (factory == null) {
- factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ factory = Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
}

assertNotNull(key, "key");
=======================================
--- /stajistics-core/src/main/java/org/stajistics/io/StatsFilterWriter.java
Wed Jul 6 09:42:09 2011
+++ /stajistics-core/src/main/java/org/stajistics/io/StatsFilterWriter.java
Sun Jul 31 22:38:26 2011
@@ -6,6 +6,7 @@
import java.io.IOException;
import java.io.Writer;

+import org.stajistics.Stats;
import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
@@ -29,7 +30,7 @@
super(out);

if (factory == null) {
- factory =
StatsFactory.forNamespace(StatsConstants.DEFAULT_NAMESPACE);
+ factory = Stats.getFactory(StatsConstants.DEFAULT_NAMESPACE);
}

assertNotNull(key, "key");
=======================================
---
/stajistics-core/src/main/java/org/stajistics/util/FastPutsLinkedMap.java
Mon Jun 20 15:36:53 2011
+++
/stajistics-core/src/main/java/org/stajistics/util/FastPutsLinkedMap.java
Sun Jul 31 22:38:26 2011
@@ -89,8 +89,8 @@

@Override
public V put(final K key, final V value) {
- size = 0;
- LinkedEntry<K,V> newEntry = new LinkedEntry(key, value, header,
header.prev);
+ size = 0; // reset
+ LinkedEntry<K,V> newEntry = new LinkedEntry<K,V>(key, value,
header, header.prev);
newEntry.prev.next = newEntry;
newEntry.next.prev = newEntry;
return null;
@@ -107,7 +107,7 @@
public V remove(final Object key) {
LinkedEntry<K,V> entry = getEntry(key);
if (entry != null) {
- size = 0;
+ size = 0; // reset
final V value = entry.getValue();
do {
remove(entry);
=======================================
--- /stajistics-core/src/main/java/org/stajistics/util/Misc.java Tue Jul 5
10:11:22 2011
+++ /stajistics-core/src/main/java/org/stajistics/util/Misc.java Sun Jul 31
22:38:26 2011
@@ -2,6 +2,7 @@

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
+import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

@@ -92,7 +93,7 @@
logger + ", " +
error + ", " +
message + ", " +
- args + ")");
+ Arrays.toString(args) + ")");
return;
}

=======================================
---
/stajistics-core/src/test/java/org/stajistics/DefaultStatsManagerTest.java
Wed Jul 6 11:14:38 2011
+++
/stajistics-core/src/test/java/org/stajistics/DefaultStatsManagerTest.java
Sun Jul 31 22:38:26 2011
@@ -30,7 +30,6 @@
import org.stajistics.event.EventManager;
import org.stajistics.event.EventType;
import org.stajistics.session.StatsSessionManager;
-import org.stajistics.tracker.TrackerLocator;

/**
*
@@ -51,7 +50,6 @@
assertNotNull(mgr.getConfigManager());
assertNotNull(mgr.getSessionManager());
assertNotNull(mgr.getEventManager());
- assertNotNull(mgr.getTrackerLocator());
assertNotNull(mgr.getConfigBuilderFactory());
}

@@ -61,7 +59,6 @@

mockery.mock(StatsConfigManager.class),

mockery.mock(StatsSessionManager.class),

mockery.mock(EventManager.class),
-
mockery.mock(TrackerLocator.class),

mockery.mock(StatsKeyFactory.class),

mockery.mock(StatsConfigBuilderFactory.class));
assertNull(manager.getNamespace());
@@ -73,7 +70,6 @@

mockery.mock(StatsConfigManager.class),

mockery.mock(StatsSessionManager.class),

mockery.mock(EventManager.class),
-
mockery.mock(TrackerLocator.class),

mockery.mock(StatsKeyFactory.class),

mockery.mock(StatsConfigBuilderFactory.class));
assertNull(manager.getNamespace());
@@ -86,7 +82,6 @@
null,

mockery.mock(StatsSessionManager.class),
mockery.mock(EventManager.class),
- mockery.mock(TrackerLocator.class),
mockery.mock(StatsKeyFactory.class),

mockery.mock(StatsConfigBuilderFactory.class));
fail("Allowed null StatsConfigManager");
@@ -102,7 +97,6 @@
mockery.mock(StatsConfigManager.class),
null,
mockery.mock(EventManager.class),
- mockery.mock(TrackerLocator.class),
mockery.mock(StatsKeyFactory.class),

mockery.mock(StatsConfigBuilderFactory.class));
fail("Allowed null StatsSessionManager");
@@ -118,7 +112,6 @@
mockery.mock(StatsConfigManager.class),

mockery.mock(StatsSessionManager.class),
null,
- mockery.mock(TrackerLocator.class),
mockery.mock(StatsKeyFactory.class),

mockery.mock(StatsConfigBuilderFactory.class));
fail("Allowed null EventManager");
@@ -126,22 +119,6 @@
assertEquals("eventManager", npe.getMessage());
}
}
-
- @Test
- public void testConstructWithNullTrackerLocator() {
- try {
- new DefaultStatsManager("ns",
- mockery.mock(StatsConfigManager.class),
-
mockery.mock(StatsSessionManager.class),
- mockery.mock(EventManager.class),
- null,
- mockery.mock(StatsKeyFactory.class),
-
mockery.mock(StatsConfigBuilderFactory.class));
- fail("Allowed null TrackerLocator");
- } catch (NullPointerException npe) {
- assertEquals("trackerLocator", npe.getMessage());
- }
- }

@Test
public void testConstructWithNullKeyFactory() {
@@ -150,7 +127,6 @@
mockery.mock(StatsConfigManager.class),

mockery.mock(StatsSessionManager.class),
mockery.mock(EventManager.class),
- mockery.mock(TrackerLocator.class),
null,

mockery.mock(StatsConfigBuilderFactory.class));
fail("Allowed null StatsKeyFactory");
@@ -166,7 +142,6 @@
mockery.mock(StatsConfigManager.class),

mockery.mock(StatsSessionManager.class),
mockery.mock(EventManager.class),
- mockery.mock(TrackerLocator.class),
mockery.mock(StatsKeyFactory.class),
null);
fail("Allowed null StatsConfigBuilderFactory");
@@ -196,7 +171,6 @@
final StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
final StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
final EventManager eventManager = mockery.mock(EventManager.class);
- final TrackerLocator trackerLocator =
mockery.mock(TrackerLocator.class);
final StatsKeyFactory keyFactory =
mockery.mock(StatsKeyFactory.class);
final StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -204,7 +178,6 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,

configBuilderFactory);

@@ -235,7 +208,6 @@
final StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
final StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
final EventManager eventManager = mockery.mock(EventManager.class);
- final TrackerLocator trackerLocator =
mockery.mock(TrackerLocator.class);
final StatsKeyFactory keyFactory =
mockery.mock(StatsKeyFactory.class);
final StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -243,7 +215,6 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,

configBuilderFactory);

@@ -268,7 +239,6 @@
StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
EventManager eventManager = mockery.mock(EventManager.class);
- TrackerLocator trackerLocator = mockery.mock(TrackerLocator.class);
StatsKeyFactory keyFactory = mockery.mock(StatsKeyFactory.class);
StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -276,7 +246,6 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,
configBuilderFactory);

@@ -288,7 +257,6 @@
StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
EventManager eventManager = mockery.mock(EventManager.class);
- TrackerLocator trackerLocator = mockery.mock(TrackerLocator.class);
StatsKeyFactory keyFactory = mockery.mock(StatsKeyFactory.class);
StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -296,7 +264,6 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,
configBuilderFactory);

@@ -308,7 +275,6 @@
StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
EventManager eventManager = mockery.mock(EventManager.class);
- TrackerLocator trackerLocator = mockery.mock(TrackerLocator.class);
StatsKeyFactory keyFactory = mockery.mock(StatsKeyFactory.class);
StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -316,40 +282,17 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,
configBuilderFactory);

assertSame(eventManager, mgr.getEventManager());
}
-
- @Test
- public void testGetTrackerLocator() {
- StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
- StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
- EventManager eventManager = mockery.mock(EventManager.class);
-
- TrackerLocator trackerLocator = mockery.mock(TrackerLocator.class);
- StatsKeyFactory keyFactory = mockery.mock(StatsKeyFactory.class);
- StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);
-
- StatsManager mgr = new DefaultStatsManager("ns",
- configManager,
- sessionManager,
- eventManager,
- trackerLocator,
- keyFactory,
- configBuilderFactory);
-
- assertSame(trackerLocator, mgr.getTrackerLocator());
- }

@Test
public void testGetKeyFactory() {
StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
EventManager eventManager = mockery.mock(EventManager.class);
- TrackerLocator trackerLocator = mockery.mock(TrackerLocator.class);
StatsKeyFactory keyFactory = mockery.mock(StatsKeyFactory.class);
StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -357,7 +300,6 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,
configBuilderFactory);

@@ -369,7 +311,6 @@
StatsConfigManager configManager =
mockery.mock(StatsConfigManager.class);
StatsSessionManager sessionManager =
mockery.mock(StatsSessionManager.class);
EventManager eventManager = mockery.mock(EventManager.class);
- TrackerLocator trackerLocator = mockery.mock(TrackerLocator.class);
StatsKeyFactory keyFactory = mockery.mock(StatsKeyFactory.class);
StatsConfigBuilderFactory configBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

@@ -377,7 +318,6 @@
configManager,
sessionManager,
eventManager,
- trackerLocator,
keyFactory,
configBuilderFactory);

@@ -400,12 +340,14 @@
StatsManager manager = newDefaultStatsManager();

// Populate the data structures a bit
+ StatsFactory factory = new DefaultStatsFactory(manager);
+
StatsKey key1 = manager.getKeyFactory().createKey("test1");
- manager.getTrackerLocator().getSpanTracker(key1).track().commit();
+ factory.getSpanTracker(key1).track().commit();
StatsKey key2 = manager.getKeyFactory().createKey("test2");
- manager.getTrackerLocator().getSpanTracker(key2).track().commit();
+ factory.getSpanTracker(key2).track().commit();
StatsKey key3 = manager.getKeyFactory().createKey("test3");
- manager.getTrackerLocator().getSpanTracker(key3).track().commit();
+ factory.getSpanTracker(key3).track().commit();

assertSerializable(manager);
}
=======================================
--- /stajistics-core/src/test/java/org/stajistics/Issue32Test.java Tue Jul
5 10:11:22 2011
+++ /stajistics-core/src/test/java/org/stajistics/Issue32Test.java Sun Jul
31 22:38:26 2011
@@ -29,7 +29,7 @@
@Test
public void
testIndividualConfigAttributesAreNotInheritedFromParentConfigs() {
StatsManager statsManager = new
DefaultStatsManagerFactory().createManager(StatsConstants.DEFAULT_NAMESPACE);
- StatsFactory factory = new StatsFactory(statsManager);
+ StatsFactory factory = new DefaultStatsFactory(statsManager);

StatsConfig defaultRootConfig = statsManager.getConfigManager()
.getRootConfig();
=======================================
--- /stajistics-core/src/test/java/org/stajistics/TestApp.java Wed Jul 6
11:14:38 2011
+++ /stajistics-core/src/test/java/org/stajistics/TestApp.java Sun Jul 31
22:38:26 2011
@@ -11,7 +11,7 @@

public static void main(String[] args) throws Exception {

- StatsFactory statsFactory = StatsFactory.forClass(TestApp.class);
+ StatsFactory statsFactory = Stats.getFactory(TestApp.class);

StatsKey key = statsFactory.newKey("Test1");

=======================================
--- /stajistics-core/src/test/java/org/stajistics/TestUtil.java Tue Jul 5
10:11:22 2011
+++ /stajistics-core/src/test/java/org/stajistics/TestUtil.java Sun Jul 31
22:38:26 2011
@@ -18,14 +18,15 @@

import org.jmock.Expectations;
import org.jmock.Mockery;
-import org.stajistics.bootstrap.DefaultStatsManagerFactory;
+import org.stajistics.configuration.StatsConfig;
import org.stajistics.configuration.StatsConfigBuilderFactory;
import org.stajistics.configuration.StatsConfigManager;
import org.stajistics.event.EventManager;
+import org.stajistics.session.StatsSessionFactory;
import org.stajistics.session.StatsSessionManager;
+import org.stajistics.session.recorder.DataRecorderFactory;
import org.stajistics.tracker.Tracker;
-import org.stajistics.tracker.TrackerLocator;
-import org.stajistics.tracker.manual.ManualTracker;
+import org.stajistics.tracker.TrackerFactory;

/**
*
@@ -66,10 +67,45 @@
}
}});
}
+
+ public static void buildStatsConfigExpectations(final Mockery mockery,
+ final StatsKey mockKey,
+ final StatsConfig
mockConfig) {
+ buildStatsConfigExpectations(mockery, mockKey, mockConfig,
true, "ms.", null);
+ }
+
+ public static void buildStatsConfigExpectations(final Mockery mockery,
+ final StatsKey mockKey,
+ final StatsConfig
mockConfig,
+ final boolean enabled,
+ final String unit,
+ final String
description) {
+ final TrackerFactory<?> mockTrackerFactory =
mockery.mock(TrackerFactory.class, "trackerFactory_" + mockKey.getName());
+ final StatsSessionFactory mockSessionFactory =
mockery.mock(StatsSessionFactory.class, "sessionFactory_" +
mockKey.getName());
+ final DataRecorderFactory mockDataRecorderFactory =
mockery.mock(DataRecorderFactory.class, "dataRecorderFactory_" +
mockKey.getName());
+
+ mockery.checking(new Expectations() {{
+ allowing(mockConfig).isEnabled();
+ will(returnValue(enabled));
+
+ allowing(mockConfig).getUnit();
+ will(returnValue(unit));
+
+ allowing(mockConfig).getTrackerFactory();
+ will(returnValue(mockTrackerFactory));
+
+ allowing(mockConfig).getSessionFactory();
+ will(returnValue(mockSessionFactory));
+
+ allowing(mockConfig).getDataRecorderFactory();
+ will(returnValue(mockDataRecorderFactory));
+
+ allowing(mockConfig).getDescription();
+ will(returnValue(description));
+ }});
+ }

/**
- * TODO: this needs more work to be useful
- *
* @param mockery
* @param mockKey
* @return
@@ -81,25 +117,61 @@
final StatsConfigManager mockConfigManager =
mockery.mock(StatsConfigManager.class);
final EventManager mockEventManager =
mockery.mock(EventManager.class);
final StatsSessionManager mockSessionManager =
mockery.mock(StatsSessionManager.class);
- final TrackerLocator mockTrackerLocator =
mockery.mock(TrackerLocator.class);
final StatsKeyFactory mockKeyFactory =
mockery.mock(StatsKeyFactory.class);
final StatsConfigBuilderFactory mockConfigBuilderFactory =
mockery.mock(StatsConfigBuilderFactory.class);

- final Tracker mockTracker = mockery.mock(Tracker.class);
- final ManualTracker mockManualTracker =
mockery.mock(ManualTracker.class);
-
mockery.checking(new Expectations() {{
- allowing(mockManager).getConfigBuilderFactory();
will(returnValue(mockConfigBuilderFactory));
- allowing(mockManager).getConfigManager();
will(returnValue(mockConfigManager));
- allowing(mockManager).getEventManager();
will(returnValue(mockEventManager));
- allowing(mockManager).getKeyFactory();
will(returnValue(mockKeyFactory));
- allowing(mockManager).getSessionManager();
will(returnValue(mockSessionManager));
- allowing(mockManager).getTrackerLocator();
will(returnValue(mockTrackerLocator));
-
- allowing(mockTrackerLocator).getTracker(with(mockKey));
will(returnValue(mockTracker));
- allowing(mockTrackerLocator).getManualTracker(with(mockKey));
will(returnValue(mockManualTracker));
+ allowing(mockManager).isEnabled();
+ will(returnValue(true));
+
+ allowing(mockManager).getConfigBuilderFactory();
+ will(returnValue(mockConfigBuilderFactory));
+
+ allowing(mockManager).getConfigManager();
+ will(returnValue(mockConfigManager));
+
+ allowing(mockManager).getEventManager();
+ will(returnValue(mockEventManager));
+
+ allowing(mockManager).getKeyFactory();
+ will(returnValue(mockKeyFactory));
+
+ allowing(mockManager).getSessionManager();
+ will(returnValue(mockSessionManager));
}});

return mockManager;
}
-}
+
+ public static StatsKeyBuilder expectKeyConfiguration(final Mockery
mockery,
+ final
StatsManager mockManager,
+ final StatsKey
mockKey,
+ final StatsConfig
mockConfig,
+ final Tracker
mockTracker) {
+ final StatsKeyBuilder mockKeyBuilder =
mockery.mock(StatsKeyBuilder.class, "statsKeyBuilder_" + mockKey.getName());
+
+ mockery.checking(new Expectations() {{
+ allowing(mockKey).buildCopy();
+ will(returnValue(mockKeyBuilder));
+
+
allowing(mockManager.getKeyFactory()).createKey(mockKey.getName());
+ will(returnValue(mockKey));
+
+
allowing(mockManager.getKeyFactory()).createKeyBuilder(mockKey.getName());
+ will(returnValue(mockKeyBuilder));
+
+
allowing(mockManager.getKeyFactory()).createKeyBuilder(mockKey);
+ will(returnValue(mockKeyBuilder));
+
+
allowing(mockManager.getConfigManager()).getOrCreateConfig(mockKey);
+ will(returnValue(mockConfig));
+
+ if (mockTracker != null) {
+
allowing(mockConfig.getTrackerFactory()).createTracker(mockKey,
mockManager.getSessionManager());
+ will(returnValue(mockTracker));
+ }
+ }});
+
+ return mockKeyBuilder;
+ }
+}
=======================================
---
/stajistics-core/src/test/java/org/stajistics/aop/StatsDecoratorsTest.java
Tue Jul 5 10:11:22 2011
+++
/stajistics-core/src/test/java/org/stajistics/aop/StatsDecoratorsTest.java
Sun Jul 31 22:38:26 2011
@@ -31,7 +31,6 @@
import org.stajistics.StatsKeyBuilder;
import org.stajistics.StatsManager;
import org.stajistics.TestUtil;
-import org.stajistics.tracker.TrackerLocator;
import org.stajistics.tracker.incident.IncidentTracker;
import org.stajistics.tracker.span.SpanTracker;

@@ -43,34 +42,30 @@

private StatsDecorators decorators;

- private StatsManager mockManager;
- private TrackerLocator mockTrackerLocator;
private SpanTracker mockSpanTracker;
private StatsKey mockKey;

- private StatsFactory statsFactory;
+ private StatsFactory mockFactory;

@Before
public void setUp() {
- mockManager = mockery.mock(StatsManager.class);
- mockTrackerLocator = mockery.mock(TrackerLocator.class);
mockSpanTracker = mockery.mock(SpanTracker.class);

- statsFactory = new StatsFactory(mockManager);
+ mockFactory = mockery.mock(StatsFactory.class);

mockKey = mockery.mock(StatsKey.class);
- TestUtil.buildStatsKeyExpectations(mockery, mockKey, "test");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey, "key");

mockery.checking(new Expectations() {{
- allowing(mockManager).getTrackerLocator();
+ /*allowing(mockManager).getTrackerLocator();
will(returnValue(mockTrackerLocator));

allowing(mockTrackerLocator).getSpanTracker(mockKey);
- will(returnValue(mockSpanTracker));
+ will(returnValue(mockSpanTracker));*/
}});

- decorators = new StatsDecorators(statsFactory);
+ decorators = new StatsDecorators(mockFactory);
}

@Test
@@ -79,7 +74,7 @@
final Runnable wrappedRunnable = decorators.wrap(mockRunnable,
mockKey);

mockery.checking(new Expectations() {{
- one(mockSpanTracker).track();
+ one(mockFactory).track(mockKey);
will(returnValue(mockSpanTracker));

one(mockRunnable).run();
@@ -97,7 +92,7 @@
final Callable<Long> wrappedCallable =
decorators.wrap(mockCallable, mockKey);

mockery.checking(new Expectations() {{
- one(mockSpanTracker).track();
+ one(mockFactory).track(mockKey);
will(returnValue(mockSpanTracker));

one(mockCallable).call();
@@ -115,13 +110,9 @@
final Callable<Long> mockCallable = mockery.mock(Callable.class);
final Callable<Long> wrappedCallable =
decorators.wrap(mockCallable, mockKey);
final Exception exception = new Exception();
- final StatsKeyBuilder mockKeyBuilder =
mockery.mock(StatsKeyBuilder.class);
- final StatsKey mockKey2 = mockery.mock(StatsKey.class, "mockKey2");
- TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "test2");
- final IncidentTracker mockIncidentTracker =
mockery.mock(IncidentTracker.class);

mockery.checking(new Expectations() {{
- one(mockSpanTracker).track();
+ one(mockFactory).track(mockKey);
will(returnValue(mockSpanTracker));

one(mockCallable).call();
@@ -129,25 +120,7 @@

one(mockSpanTracker).commit();

- one(mockTrackerLocator).getIncidentTracker(mockKey2);
- will(returnValue(mockIncidentTracker));
-
- one(mockIncidentTracker).incident();
-
- one(mockKey).buildCopy();
- will(returnValue(mockKeyBuilder));
-
- //TODO: this is more-so checking the exception key handling
- // rather than callable wrapper exception handling
- one(mockKeyBuilder).withNameSuffix(with("exception"));
- will(returnValue(mockKeyBuilder));
-
- one(mockKeyBuilder).withAttribute(with("threw"),
- with("java.lang.Exception"));
- will(returnValue(mockKeyBuilder));
-
- one(mockKeyBuilder).newKey();
- will(returnValue(mockKey2));
+ one(mockFactory).failure(exception, mockKey);
}});

try {
@@ -165,7 +138,7 @@
final Observable observable = new Observable();

mockery.checking(new Expectations() {{
- one(mockSpanTracker).track();
+ one(mockFactory).track(mockKey);
will(returnValue(mockSpanTracker));

one(mockObserver).update(observable, "hello");
=======================================
--- /stajistics-core/src/test/java/org/stajistics/aop/StatsProxyTest.java
Tue Jul 5 10:11:22 2011
+++ /stajistics-core/src/test/java/org/stajistics/aop/StatsProxyTest.java
Sun Jul 31 22:38:26 2011
@@ -25,16 +25,10 @@
import org.junit.Before;
import org.junit.Test;
import org.stajistics.AbstractStajisticsTestCase;
-import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
-import org.stajistics.StatsKeyUtil;
-import org.stajistics.StatsManager;
-import org.stajistics.bootstrap.DefaultStatsManagerFactory;
-import org.stajistics.session.StatsSessionManager;
-import org.stajistics.tracker.Tracker;
-import org.stajistics.tracker.TrackerFactory;
-import org.stajistics.tracker.incident.IncidentTracker;
+import org.stajistics.StatsKeyBuilder;
+import org.stajistics.TestUtil;
import org.stajistics.tracker.span.SpanTracker;

/**
@@ -54,22 +48,44 @@

private StatsFactory mockFactory;
private StatsKey mockKey;
+ private StatsKeyBuilder mockKeyBuilder;
private Service mockService;
-
- private StatsManager statsManager;

@Before
public void setUp() {
- // TODO: this should be _actually_ mocked
- statsManager = new
DefaultStatsManagerFactory().createManager(StatsConstants.DEFAULT_NAMESPACE);
- mockFactory = new StatsFactory(statsManager);
- mockKey = statsManager.getKeyFactory().createKey("test");
+ mockKey = mockery.mock(StatsKey.class, "key1");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey, "key1");
+ mockKeyBuilder = mockery.mock(StatsKeyBuilder.class);
+
+ mockFactory = mockery.mock(StatsFactory.class);
+
mockService = mockery.mock(Service.class);
}
+
+ private StatsKey expectKeyForMethod(final String methodName) {
+ final StatsKey mockKey2 = mockery.mock(StatsKey.class, "key2");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "key2");
+
+ mockery.checking(new Expectations() {{
+ allowing(mockKey).buildCopy();
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).withAttribute("method", methodName);
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).newKey();
+ will(returnValue(mockKey2));
+ }});
+
+ return mockKey2;
+ }

@Test
public void testMethodDelegation() {
+ final StatsKey mockKey2 = expectKeyForMethod("query");
+
mockery.checking(new Expectations() {{
+ one(mockFactory).track(mockKey2);
one(mockService).query();
}});

@@ -101,40 +117,19 @@
assertInstanceOf(Service2.class, serviceImpl);
}

- @SuppressWarnings("serial")
@Test
public void testTrackMethodCall() {
-
- StatsKey methodKey = mockKey.buildCopy()
- .withAttribute("method",
StatsProxy.getMethodString(SERVICE_QUERY_METHOD))
- .newKey();
+ final StatsKey mockKey2 =
expectKeyForMethod(StatsProxy.getMethodString(SERVICE_QUERY_METHOD));

final SpanTracker mockTracker = mockery.mock(SpanTracker.class);

mockery.checking(new Expectations() {{
- one(mockTracker).track(); will(returnValue(mockTracker));
- one(mockTracker).commit();
- }});
-
- statsManager.getConfigBuilderFactory()
- .createConfigBuilder()
- .withTrackerFactory(new TrackerFactory<Tracker>() {
- @Override
- public Tracker createTracker(final StatsKey key,
- final StatsSessionManager
sessionManager) {
-
- return mockTracker;
- }
-
- @Override
- public Class<Tracker> getTrackerType() {
- return Tracker.class;
- }
- })
- .setConfigFor(methodKey);
-
- mockery.checking(new Expectations() {{
+ one(mockFactory).track(mockKey2);
+ will(returnValue(mockTracker));
+
one(mockService).query();
+
+ one(mockTracker).commit();
}});

Service serviceProxy = StatsProxy.wrap(mockFactory, mockKey,
mockService);
@@ -142,56 +137,23 @@
serviceProxy.query();
}

- @SuppressWarnings("serial")
@Test
public void testTrackExceptionIncident() {
-
- final StatsKey methodKey = mockKey.buildCopy()
- .withAttribute("method",
StatsProxy.getMethodString(SERVICE_QUERY_METHOD))
- .newKey();
- final StatsKey exceptionKey = StatsKeyUtil.keyForFailure(methodKey,
- new
IllegalStateException());
-
+ final StatsKey mockKey2 =
expectKeyForMethod(StatsProxy.getMethodString(SERVICE_QUERY_METHOD));
final SpanTracker methodTracker =
mockery.mock(SpanTracker.class, "methodTracker");
- final IncidentTracker exceptionTracker =
mockery.mock(IncidentTracker.class, "exceptionTracker");
-
- mockery.checking(new Expectations() {{
- one(methodTracker).track();
- will(returnValue(methodTracker));
- one(exceptionTracker).incident();
- will(returnValue(exceptionTracker));
- one(methodTracker).commit();
- }});
-
- statsManager.getConfigBuilderFactory()
- .createConfigBuilder()
- .withTrackerFactory(new TrackerFactory<Tracker>() {
- @Override
- public Tracker createTracker(final StatsKey key,
- final StatsSessionManager
sessionManager) {
- if (key.equals(methodKey)) {
- return methodTracker;
- }
-
- if (key.equals(exceptionKey)) {
- return exceptionTracker;
- }
-
- throw new Error("key is neither the methodKey nor the
exceptionKey");
- }
-
- @Override
- public Class<Tracker> getTrackerType() {
- return Tracker.class;
- }
- })
- .setConfigFor(methodKey);

final IllegalStateException exception = new
IllegalStateException();

mockery.checking(new Expectations() {{
+ one(mockFactory).track(mockKey2);
+ will(returnValue(methodTracker));
+
one(mockService).query();
will(throwException(exception));
+
+ one(methodTracker).commit();
+
+ one(mockFactory).failure(exception, mockKey2);
}});

Service serviceProxy = StatsProxy.wrap(mockFactory, mockKey,
mockService);
=======================================
---
/stajistics-core/src/test/java/org/stajistics/aop/StatsSelectiveProxyTest.java
Tue Jul 5 10:11:22 2011
+++
/stajistics-core/src/test/java/org/stajistics/aop/StatsSelectiveProxyTest.java
Sun Jul 31 22:38:26 2011
@@ -26,16 +26,15 @@
import org.junit.Before;
import org.junit.Test;
import org.stajistics.AbstractStajisticsTestCase;
-import org.stajistics.StatsConstants;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
-import org.stajistics.StatsManager;
+import org.stajistics.StatsKeyBuilder;
+import org.stajistics.TestUtil;
import org.stajistics.aop.StatsSelectiveProxy.EnabledCriteria;
import org.stajistics.aop.StatsSelectiveProxy.MethodCriteria;
import org.stajistics.aop.StatsSelectiveProxy.MethodModifierCriteria;
import org.stajistics.aop.StatsSelectiveProxy.MethodSetCriteria;
import org.stajistics.aop.StatsSelectiveProxy.SelectionCriteria;
-import org.stajistics.bootstrap.DefaultStatsManagerFactory;

/**
* TODO: run all StatsProxy tests against StatsSelectiveProxy
@@ -45,9 +44,9 @@
*/
public class StatsSelectiveProxyTest extends AbstractStajisticsTestCase {

- private StatsManager statsManager;
private StatsFactory mockFactory;
private StatsKey mockKey;
+ private StatsKeyBuilder mockKeyBuilder;
private Service mockService;

private static final Method PRIVATE_METHOD;
@@ -77,19 +76,44 @@

+ // TODO: Copied from StatsProxyTest -> consolidate
+ private StatsKey expectKeyForMethod(final String methodName) {
+ final StatsKey mockKey2 = mockery.mock(StatsKey.class, "key2");
+ TestUtil.buildStatsKeyExpectations(mockery, mockKey2, "key2");
+
+ mockery.checking(new Expectations() {{
+ allowing(mockKey).buildCopy();
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).withAttribute("method", methodName);
+ will(returnValue(mockKeyBuilder));
+
+ one(mockKeyBuilder).newKey();
+ will(returnValue(mockKey2));
+ }});
+
+ return mockKey2;
+ }
+
@Test
public void testInvokeWithPassingCriteria() {

+ expectKeyForMethod("query");
+
final SelectionCriteria mockCriteria =
mockery.mock(SelectionCriteria.class);

mockery.checking(new Expectations() {{
+ ignoring(mockFactory); // We're not verifying StatsProxy
behaviour here
+
one(mockCriteria).select(with(aNonNull(Method.class)),
with(any(Object[].class)));
will(returnValue(true));
@@ -112,7 +136,7 @@

mockery.checking(new Expectations() {{
one(mockCriteria).select(with(aNonNull(Method.class)),
- with(any(Object[].class)));
+ with(any(Object[].class)));
will(returnValue(false));

one(mockService).query();
=======================================
---
/stajistics-core/src/test/java/org/stajistics/bootstrap/AbstractStatsManagerFactoryTestCase.java
Wed Jul 6 11:14:38 2011
+++
/stajistics-core/src/test/java/org/stajistics/bootstrap/AbstractStatsManagerFactoryTestCase.java
Sun Jul 31 22:38:26 2011
@@ -56,12 +56,6 @@
StatsManager mgr = createManager();
assertNotNull(mgr.getSessionManager());
}
-
- @Test
- public void testManagerHasNonNullTrackerLocator() {
- StatsManager mgr = createManager();
- assertNotNull(mgr.getTrackerLocator());
- }

@Test
public void testManagerHasNonNullKeyFactory() {
=======================================
---
/stajistics-core/src/test/resources/org/stajistics/configuration/xml/testConfig.xml
Fri Jun 4 05:35:23 2010
+++
/stajistics-core/src/test/resources/org/stajistics/configuration/xml/testConfig.xml
Sun Jul 31 22:38:26 2011
@@ -1,22 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
-<stajistics xmlns="http://www.stajistics.org/configuration/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-
- <properties>
- <property name="name1">value1</property>
- <property name="name1">value1</property>
- </properties>
-
- <rootConfig>
- <sessionFactory>concurrent</sessionFactory>
- <trackerFactory>default</trackerFactory>
- <dataRecorderFactory>default</dataRecorderFactory>
- </rootConfig>
-
- <config key="org.stajistics" unit="ms" type="span">
- <description>org.stajistics Description</description>
- <sessionFactory>asynchronous</sessionFactory>
- <trackerFactory>thread-local</trackerFactory>
- <dataRecorderFactory>default</dataRecorderFactory>
- </config>
+<stajistics xmlns="http://www.stajistics.org/configuration/1.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+ 
+
+ <properties>
+ <property name="name1">value1</property>
+ <property name="name1">value1</property>
+ </properties>
+
+ <rootConfig unit="ms">
+ <sessionFactory>concurrent</sessionFactory>
+ <trackerFactory>default</trackerFactory>
+ <dataRecorderFactory>default</dataRecorderFactory>
+ </rootConfig>
+
+ <config key="org.stajistics" unit="ms" tracker-factory=""
session-factory="" data-recorder-factory="">
+ org.stajistics Description
+ </config>

</stajistics>
=======================================
---
/stajistics-examples/src/main/java/org/stajistics/examples/basic/MethodTimeDuration.java
Fri Jul 8 15:40:16 2011
+++
/stajistics-examples/src/main/java/org/stajistics/examples/basic/MethodTimeDuration.java
Sun Jul 31 22:38:26 2011
@@ -14,6 +14,7 @@
*/
package org.stajistics.examples.basic;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.tracker.span.SpanTracker;
@@ -27,7 +28,7 @@
*/
public class MethodTimeDuration implements Runnable {

- private static StatsFactory statsFactory =
StatsFactory.forClass(MethodTimeDuration.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(MethodTimeDuration.class);

public void run() {

=======================================
--- /stajistics-jdbc/pom.xml Thu Jun 2 04:43:48 2011
+++ /stajistics-jdbc/pom.xml Sun Jul 31 22:38:26 2011
@@ -23,4 +23,8 @@
</dependency>
</dependencies>

+ <properties>
+ <site.basedir>${project.parent.basedir}</site.basedir>
+ </properties>
+
</project>
=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/DefaultJDBCProxyFactory.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/DefaultJDBCProxyFactory.java
Sun Jul 31 22:38:26 2011
@@ -14,9 +14,9 @@
*/
package org.stajistics.jdbc;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
-import org.stajistics.StatsManager;
import org.stajistics.aop.ProxyFactory;
import org.stajistics.aop.StatsProxy;

@@ -42,7 +42,7 @@
}

if (factory == null) {
- this.factory = StatsFactory.forClass(getClass());
+ this.factory = Stats.getFactory(getClass());
} else {
this.factory = factory;
}
@@ -56,7 +56,7 @@
throw new NullPointerException("proxyClass");
}

- StatsFactory factory =
StatsFactory.forClass(DefaultJDBCProxyFactory.class);
+ StatsFactory factory =
Stats.getFactory(DefaultJDBCProxyFactory.class);
StatsKey key = factory.buildKey(proxyClass.getName())
.withNameSuffix("proxy")
.newKey();
=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsCallableStatementWrapper.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsCallableStatementWrapper.java
Sun Jul 31 22:38:26 2011
@@ -21,6 +21,7 @@
import java.util.LinkedList;
import java.util.List;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.aop.ProxyFactory;
@@ -35,7 +36,7 @@
*/
public class StatsCallableStatementWrapper extends
AbstractCallableStatementDecorator {

- private static StatsFactory statsFactory =
StatsFactory.forClass(StatsCallableStatementWrapper.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(StatsCallableStatementWrapper.class);

private final StatsJDBCConfig config;

=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsConnectionWrapper.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsConnectionWrapper.java
Sun Jul 31 22:38:26 2011
@@ -20,6 +20,7 @@
import java.sql.SQLException;
import java.sql.Statement;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.aop.ProxyFactory;
@@ -35,7 +36,7 @@
*/
public class StatsConnectionWrapper extends AbstractConnectionDecorator {

- private static StatsFactory statsFactory =
StatsFactory.forClass(StatsConnectionWrapper.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(StatsConnectionWrapper.class);

private final StatsJDBCConfig config;

=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsPooledConnectionWrapper.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsPooledConnectionWrapper.java
Sun Jul 31 22:38:26 2011
@@ -23,6 +23,7 @@
import javax.sql.StatementEvent;
import javax.sql.StatementEventListener;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.jdbc.StatsJDBCConfig;
@@ -36,7 +37,7 @@
*/
public class StatsPooledConnectionWrapper extends
AbstractPooledConnectionDecorator {

- private static StatsFactory statsFactory =
StatsFactory.forClass(StatsPooledConnectionWrapper.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(StatsPooledConnectionWrapper.class);

private final StatsJDBCConfig config;

=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsPreparedStatementWrapper.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsPreparedStatementWrapper.java
Sun Jul 31 22:38:26 2011
@@ -21,6 +21,7 @@
import java.util.LinkedList;
import java.util.List;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.aop.ProxyFactory;
@@ -36,7 +37,7 @@
*/
public class StatsPreparedStatementWrapper extends
AbstractPreparedStatementDecorator {

- private static StatsFactory statsFactory =
StatsFactory.forClass(StatsPreparedStatementWrapper.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(StatsPreparedStatementWrapper.class);

private final Connection connection;
private final String sql;
=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsResultSetWrapper.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsResultSetWrapper.java
Sun Jul 31 22:38:26 2011
@@ -17,6 +17,7 @@
import java.sql.ResultSet;
import java.sql.SQLException;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.jdbc.StatsJDBCConfig;
@@ -30,7 +31,7 @@
*/
public class StatsResultSetWrapper extends AbstractResultSetDecorator {

- private static StatsFactory statsFactory =
StatsFactory.forClass(StatsResultSetWrapper.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(StatsResultSetWrapper.class);

private final StatsJDBCConfig config;

=======================================
---
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsStatementWrapper.java
Fri Jul 8 15:40:00 2011
+++
/stajistics-jdbc/src/main/java/org/stajistics/jdbc/wrapper/StatsStatementWrapper.java
Sun Jul 31 22:38:26 2011
@@ -21,6 +21,7 @@
import java.util.LinkedList;
import java.util.List;

+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.aop.ProxyFactory;
@@ -35,7 +36,7 @@
*/
public class StatsStatementWrapper extends AbstractStatementDecorator {

- private static StatsFactory statsFactory =
StatsFactory.forClass(StatsStatementWrapper.class);
+ private static StatsFactory statsFactory =
Stats.getFactory(StatsStatementWrapper.class);

private final StatsJDBCConfig config;

=======================================
--- /stajistics-servlet/pom.xml Thu Jun 2 04:43:48 2011
+++ /stajistics-servlet/pom.xml Sun Jul 31 22:38:26 2011
@@ -41,4 +41,8 @@
</dependency>
</dependencies>

+ <properties>
+ <site.basedir>${project.parent.basedir}</site.basedir>
+ </properties>
+
</project>
=======================================
---
/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsFilter.java
Fri Jul 8 15:39:41 2011
+++
/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsFilter.java
Sun Jul 31 22:38:26 2011
@@ -30,6 +30,7 @@

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.stajistics.Stats;
import org.stajistics.StatsFactory;
import org.stajistics.StatsKey;
import org.stajistics.configuration.StatsConfig;
@@ -86,9 +87,9 @@

String namespace = config.getInitParameter(INIT_PARAM_NAMESPACE);
if (namespace != null) {
- statsFactory = StatsFactory.forNamespace(namespace);
+ statsFactory = Stats.getFactory(namespace);
} else {
- statsFactory = StatsFactory.forClass(StatsFilter.class);
+ statsFactory = Stats.getFactory(StatsFilter.class);
}

String keyName = config.getInitParameter(INIT_PARAM_KEY_NAME);
=======================================
---
/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsHttpServletRequest.java
Fri Jul 8 15:39:41 2011
+++
/stajistics-servlet/src/main/java/org/stajistics/integration/servlet/StatsHttpServletRequest.java
Sun Jul 31 22:38:26 2011
@@ -4,7 +4,6 @@

import java.io.BufferedReader;
import java.io.IOException;
-import java.io.Reader;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
=======================================
***Additional files exist in this changeset.***

Reply all

Reply to author

Forward

0 new messages