diff --git a/roboquant-avro/src/test/kotlin/org/roboquant/samples/AvroSamples.kt b/roboquant-avro/src/test/kotlin/org/roboquant/samples/AvroSamples.kt index dc46bff5..a725c794 100644 --- a/roboquant-avro/src/test/kotlin/org/roboquant/samples/AvroSamples.kt +++ b/roboquant-avro/src/test/kotlin/org/roboquant/samples/AvroSamples.kt @@ -138,16 +138,9 @@ internal class AvroSamples { @Test @Ignore internal fun signalsOnly() { - class MyPolicy : BasePolicy(prefix = "") { - - init { - enableMetrics = true - } + class MyPolicy : BasePolicy() { override fun act(signals: List, account: Account, event: Event): List { - for (signal in signals) { - record("signal.${signal.asset.symbol}", signal.rating) - } return emptyList() } diff --git a/roboquant-binance/src/test/kotlin/org/roboquant/binance/BinanceHistoricFeedTestIT.kt b/roboquant-binance/src/test/kotlin/org/roboquant/binance/BinanceHistoricFeedTestIT.kt index 50b52afb..6abc08a1 100644 --- a/roboquant-binance/src/test/kotlin/org/roboquant/binance/BinanceHistoricFeedTestIT.kt +++ b/roboquant-binance/src/test/kotlin/org/roboquant/binance/BinanceHistoricFeedTestIT.kt @@ -26,13 +26,14 @@ internal class BinanceHistoricFeedTestIT { @Test fun test() { val feed = BinanceHistoricFeed() - assertEquals(1, feed.availableAssets.findBySymbols("BTCUST").size) + val symbol = "BTCUSDT" + assertEquals(1, feed.availableAssets.findBySymbols(symbol).size) - val asset = feed.availableAssets.getBySymbol("BTCUST") + val asset = feed.availableAssets.getBySymbol(symbol) assertEquals(asset.type, AssetType.CRYPTO) val tf = Timeframe.past(100.days) - feed.retrieve("BTCBUSD", timeframe = tf) + feed.retrieve(symbol, timeframe = tf) assertEquals(1, feed.assets.size) assertThrows { diff --git a/roboquant-ml/src/main/kotlin/org/roboquant/ml/RegressionStrategy.kt b/roboquant-ml/src/main/kotlin/org/roboquant/ml/RegressionStrategy.kt index eeeabc00..4ce29172 100644 --- a/roboquant-ml/src/main/kotlin/org/roboquant/ml/RegressionStrategy.kt +++ b/roboquant-ml/src/main/kotlin/org/roboquant/ml/RegressionStrategy.kt @@ -21,8 +21,8 @@ import org.roboquant.common.Logging import org.roboquant.common.addNotNull import org.roboquant.common.percent import org.roboquant.feeds.Event -import org.roboquant.strategies.RecordingStrategy import org.roboquant.strategies.Signal +import org.roboquant.strategies.Strategy import smile.data.DataFrame import smile.regression.DataFrameRegression @@ -34,11 +34,10 @@ open class RegressionStrategy( private val asset: Asset, private val percentage: Double = 1.percent, val block: (DataFrame) -> DataFrameRegression -) : RecordingStrategy() { +) : Strategy { private val logger = Logging.getLogger(this::class) private var trained = false - private val metricName = "prediction.${asset.symbol.lowercase()}" private lateinit var model: DataFrameRegression @@ -50,7 +49,6 @@ open class RegressionStrategy( private fun predict(): Double { val df = featureSet.getPredictData() val result = model.predict(df).last() - record(metricName, result) return result } diff --git a/roboquant-ml/src/test/kotlin/org/roboquant/samples/MLSamples.kt b/roboquant-ml/src/test/kotlin/org/roboquant/samples/MLSamples.kt index cc6e0e2d..6e0cb201 100644 --- a/roboquant-ml/src/test/kotlin/org/roboquant/samples/MLSamples.kt +++ b/roboquant-ml/src/test/kotlin/org/roboquant/samples/MLSamples.kt @@ -68,7 +68,6 @@ internal class MLSamples { println(model.importance().toList()) model } - s.recording = true return s } diff --git a/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/QuestDBMetricsLogger.kt b/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/QuestDBMetricsLogger.kt index 3f9d4ce5..2b571a82 100644 --- a/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/QuestDBMetricsLogger.kt +++ b/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/QuestDBMetricsLogger.kt @@ -22,19 +22,37 @@ import io.questdb.cairo.TableWriter import io.questdb.griffin.SqlException import io.questdb.griffin.SqlExecutionContext import io.questdb.griffin.SqlExecutionContextImpl -import org.roboquant.common.* +import org.roboquant.common.Config +import org.roboquant.common.Logging +import org.roboquant.common.Observation +import org.roboquant.common.TimeSeries import org.roboquant.loggers.MetricsLogger import java.nio.file.Files import java.nio.file.Path import java.time.Instant import java.util.concurrent.ConcurrentSkipListSet +import kotlin.collections.Map +import kotlin.collections.Set +import kotlin.collections.component1 +import kotlin.collections.component2 +import kotlin.collections.iterator +import kotlin.collections.mutableListOf +import kotlin.collections.mutableMapOf +import kotlin.collections.set +import kotlin.collections.setOf +import kotlin.collections.toSet +import kotlin.collections.toSortedSet import kotlin.io.path.div import kotlin.io.path.isDirectory /** * Log metrics to a QuestDB database */ -class QuestDBMetricsLogger(dbPath: Path = Config.home / "questdb-metrics" / "db", workers: Int = 1) : MetricsLogger { +class QuestDBMetricsLogger( + dbPath: Path = Config.home / "questdb-metrics" / "db", + workers: Int = 1, + private val partition: String = QuestDBRecorder.NONE +) : MetricsLogger { private val logger = Logging.getLogger(this::class) private var engine: CairoEngine @@ -43,6 +61,7 @@ class QuestDBMetricsLogger(dbPath: Path = Config.home / "questdb-metrics" / "db" private val tables = ConcurrentSkipListSet() init { + require(partition in setOf("YEAR", "MONTH", "DAY", "HOUR", "NONE")) { "invalid partition value" } if (Files.notExists(dbPath)) { logger.info { "Creating new database path=$dbPath" } Files.createDirectories(dbPath) @@ -158,7 +177,7 @@ class QuestDBMetricsLogger(dbPath: Path = Config.home / "questdb-metrics" / "db" |metric SYMBOL, |value DOUBLE, |time TIMESTAMP - |), INDEX(metric) timestamp(time)""".trimMargin(), + |), INDEX(metric) timestamp(time) PARTITION BY $partition""".trimMargin(), ) engine.update("TRUNCATE TABLE '$tableName'") diff --git a/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/extensions.kt b/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/extensions.kt index 30461468..502ab3ac 100644 --- a/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/extensions.kt +++ b/roboquant-questdb/src/main/kotlin/org/roboquant/questdb/extensions.kt @@ -90,7 +90,7 @@ internal fun CairoEngine.dropTable(tableName: String) { internal fun CairoEngine.tableColumns(tableName: String): Set { val result = mutableSetOf() - query("select column from table_columns('$tableName')") { + query("select \"column\" from table_columns('$tableName')") { while (hasNext()) { result.add(record.getStr(0).toString()) } diff --git a/roboquant-ta/src/main/kotlin/org/roboquant/ta/RSIStrategy.kt b/roboquant-ta/src/main/kotlin/org/roboquant/ta/RSIStrategy.kt index 634570b6..6ca293ea 100644 --- a/roboquant-ta/src/main/kotlin/org/roboquant/ta/RSIStrategy.kt +++ b/roboquant-ta/src/main/kotlin/org/roboquant/ta/RSIStrategy.kt @@ -20,8 +20,8 @@ import org.roboquant.common.Asset import org.roboquant.common.PriceSeries import org.roboquant.common.addAll import org.roboquant.feeds.Event -import org.roboquant.strategies.RecordingStrategy import org.roboquant.strategies.Signal +import org.roboquant.strategies.Strategy /** * Strategy using the Relative Strength MetadataProvider of an asset to generate signals. RSI measures the magnitude @@ -40,7 +40,7 @@ class RSIStrategy( val highThreshold: Double = 70.0, private val windowSize: Int = 14, private val priceType: String = "DEFAULT" -) : RecordingStrategy(prefix = "rsi.") { +) : Strategy { private val history = mutableMapOf() private val taLib = TaLib() @@ -53,7 +53,6 @@ class RSIStrategy( } /** - * @see RecordingStrategy.generate */ override fun generate(event: Event): List { history.addAll(event, 1, priceType) @@ -63,7 +62,6 @@ class RSIStrategy( try { if (data.isFull()) { val rsi = taLib.rsi(data.toDoubleArray(), windowSize) - record(asset.symbol, rsi) if (rsi > highThreshold) result.add(Signal.sell(asset)) else if (rsi < lowThreshold) diff --git a/roboquant-ta/src/main/kotlin/org/roboquant/ta/TaLibStrategy.kt b/roboquant-ta/src/main/kotlin/org/roboquant/ta/TaLibStrategy.kt index fee1815b..45575d1a 100644 --- a/roboquant-ta/src/main/kotlin/org/roboquant/ta/TaLibStrategy.kt +++ b/roboquant-ta/src/main/kotlin/org/roboquant/ta/TaLibStrategy.kt @@ -20,7 +20,6 @@ package org.roboquant.ta import org.roboquant.feeds.Event import org.roboquant.feeds.PriceBar -import org.roboquant.strategies.RecordingStrategy import org.roboquant.strategies.Signal import org.roboquant.strategies.Strategy import java.lang.Integer.max @@ -34,7 +33,7 @@ import java.lang.Integer.max * If not enough history is available to calculate the indicators, the capacity will be automatically increased until * it is able to perform the calculations. */ -class TaLibStrategy(initialCapacity: Int = 1) : RecordingStrategy(recording = true) { +class TaLibStrategy(initialCapacity: Int = 1) : Strategy { private var sellFn: TaLib.(series: PriceBarSeries) -> Boolean = { false } private var buyFn: TaLib.(series: PriceBarSeries) -> Boolean = { false } diff --git a/roboquant/src/main/kotlin/org/roboquant/Roboquant.kt b/roboquant/src/main/kotlin/org/roboquant/Roboquant.kt index 63d2ecf6..d805d3fb 100644 --- a/roboquant/src/main/kotlin/org/roboquant/Roboquant.kt +++ b/roboquant/src/main/kotlin/org/roboquant/Roboquant.kt @@ -175,9 +175,6 @@ data class Roboquant( */ private fun getMetrics(account: Account, event: Event) = buildMap { for (metric in metrics) putAll(metric.calculate(account, event)) - putAll(strategy.getMetrics()) - putAll(policy.getMetrics()) - putAll(broker.getMetrics()) kotlinLogger.trace { "captured metrics=$size" } } diff --git a/roboquant/src/main/kotlin/org/roboquant/brokers/Broker.kt b/roboquant/src/main/kotlin/org/roboquant/brokers/Broker.kt index d76eaf20..7e05f3e5 100644 --- a/roboquant/src/main/kotlin/org/roboquant/brokers/Broker.kt +++ b/roboquant/src/main/kotlin/org/roboquant/brokers/Broker.kt @@ -42,12 +42,6 @@ interface Broker { */ fun place(orders: List) - /** - * This method will be invoked at each step in a run and provides the broker with the opportunity to - * provide additional metrics. The default implementation returns an empty map. - */ - fun getMetrics(): Map = emptyMap() - /** * Reset the state of the component to its initial state. The default implementation is to take no action. */ diff --git a/roboquant/src/main/kotlin/org/roboquant/common/Logging.kt b/roboquant/src/main/kotlin/org/roboquant/common/Logging.kt index c2bf27b3..bbcb3c65 100644 --- a/roboquant/src/main/kotlin/org/roboquant/common/Logging.kt +++ b/roboquant/src/main/kotlin/org/roboquant/common/Logging.kt @@ -30,7 +30,7 @@ object Logging { /** * Logger class that extends a SLF4J logger and allows for Kotlin idiomatic usage patterns */ - class Logger(private val slf4jLogger: org.slf4j.Logger) : org.slf4j.Logger by slf4jLogger { + class Logger(@Suppress("unused") private val slf4jLogger: org.slf4j.Logger) : org.slf4j.Logger by slf4jLogger { /** * @see org.slf4j.Logger.trace diff --git a/roboquant/src/main/kotlin/org/roboquant/policies/BasePolicy.kt b/roboquant/src/main/kotlin/org/roboquant/policies/BasePolicy.kt index a74d57ec..d9f65d46 100644 --- a/roboquant/src/main/kotlin/org/roboquant/policies/BasePolicy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/policies/BasePolicy.kt @@ -22,7 +22,6 @@ import org.roboquant.common.Asset import org.roboquant.orders.MarketOrder import org.roboquant.orders.Order import org.roboquant.orders.createCancelOrders -import kotlin.collections.set /** * Contains a number of utility methods that are useful when implementing a new policy. @@ -30,43 +29,8 @@ import kotlin.collections.set * For example, how to deal with conflicting signals or how to handle amounts in a multi-currency environment. It * also contains a simple method to record metrics. * - * @property enableMetrics should metrics be exposed, default is false */ -abstract class BasePolicy(private val prefix: String = "policy.") : Policy { - - /** - * should metrics be exposed, default is false - */ - var enableMetrics: Boolean = false - - private val metrics = mutableMapOf() - - /** - * Record a metric - * - * @param key The name of the metric - * @param value The value of the metric - */ - protected fun record(key: String, value: Number) { - if (!enableMetrics) return - metrics["$prefix$key"] = value.toDouble() - } - - /** - * Return any recorded metrics - */ - override fun getMetrics(): Map { - val result = metrics.toMap() - metrics.clear() - return result - } - - /** - * Reset the state, including any recorded metrics. - */ - override fun reset() { - metrics.clear() - } +abstract class BasePolicy : Policy { /** * Create a new market-order to close an open position for an [asset] and cancel-orders any open orders for diff --git a/roboquant/src/main/kotlin/org/roboquant/policies/FlexPolicy.kt b/roboquant/src/main/kotlin/org/roboquant/policies/FlexPolicy.kt index 4b1a8144..c5d9a2bf 100644 --- a/roboquant/src/main/kotlin/org/roboquant/policies/FlexPolicy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/policies/FlexPolicy.kt @@ -68,7 +68,6 @@ open class FlexPolicyConfig( * For example, this policy will create [MarketOrder]s by default, but this can be changed by overwriting * the [createOrder] method in a subclass. * - * When [enableMetrics] is set to true, it will record the number of `actions`, `signals` and `orders`. * * @constructor Create a new instance of a FlexPolicy * @param configure additional configuration parameters @@ -255,20 +254,6 @@ open class FlexPolicy( */ private operator fun Collection.contains(asset: Asset) = any { it.asset == asset } - /** - * Record basic metrics: `actions`, `signals`, `orders.new`, `orders.open`, - * `positions` and `buyingpower`. - * - * The main purpose is to better understand when the policy is not behaving as expected. - */ - open fun record(orders: List, signals: List, event: Event, account: Account) { - record("actions", event.items.size) - record("signals", signals.size) - record("orders.new", orders.size) - record("orders.open", account.openOrders.size) - record("positions", account.positions.size) - record("buyingpower", account.buyingPower.value) - } /** * @see Policy.act @@ -327,7 +312,6 @@ open class FlexPolicy( } } - if (enableMetrics) record(orders, signals, event, account) return orders } } diff --git a/roboquant/src/main/kotlin/org/roboquant/policies/Policy.kt b/roboquant/src/main/kotlin/org/roboquant/policies/Policy.kt index 3b823218..27edd07c 100644 --- a/roboquant/src/main/kotlin/org/roboquant/policies/Policy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/policies/Policy.kt @@ -46,13 +46,6 @@ interface Policy { */ fun act(signals: List, account: Account, event: Event): List - /** - * This will be invoked at each step in a run and provides the implementation with the opportunity to log additional - * information. The default implementation is to return an empty map. - * - * This map does not mutate after it has been returned by this method. - */ - fun getMetrics(): Map = emptyMap() /** * Reset the state of the component to its initial state. The default implementation is to take no action. diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/CombinedStrategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/CombinedStrategy.kt index 0d755c5a..40ed3947 100644 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/CombinedStrategy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/strategies/CombinedStrategy.kt @@ -44,9 +44,4 @@ open class CombinedStrategy(val strategies: Collection) : Strategy { for (strategy in strategies) strategy.reset() } - override fun getMetrics(): Map { - val result = mutableMapOf() - strategies.forEach { result += it.getMetrics() } - return result - } } diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/EMAStrategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/EMAStrategy.kt index d12f0718..afa3f590 100644 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/EMAStrategy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/strategies/EMAStrategy.kt @@ -46,7 +46,7 @@ class EMAStrategy( smoothing: Double = 2.0, private val minEvents: Int = slowPeriod, priceType: String = "DEFAULT" -) : PriceStrategy(priceType = priceType, prefix = "strategy.ema.") { +) : PriceStrategy(priceType = priceType) { private val fast = 1.0 - (smoothing / (fastPeriod + 1)) private val slow = 1.0 - (smoothing / (slowPeriod + 1)) @@ -105,11 +105,6 @@ class EMAStrategy( if (calculator.isReady()) { val newDirection = calculator.getDirection() - if (recording) { - record("${asset.symbol}.fast", calculator.emaFast) - record("${asset.symbol}.slow", calculator.emaSlow) - } - if (oldDirection != newDirection) { val rating = if (newDirection) 1.0 else -1.0 return Signal(asset, rating) diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/HistoricPriceStrategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/HistoricPriceStrategy.kt index c7440280..27fba6b1 100644 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/HistoricPriceStrategy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/strategies/HistoricPriceStrategy.kt @@ -35,7 +35,7 @@ import org.roboquant.feeds.Event abstract class HistoricPriceStrategy( private val period: Int, private val priceType: String = "DEFAULT", -) : RecordingStrategy() { +) : Strategy { /** * Contain the history of all assets diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/PriceStrategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/PriceStrategy.kt index 6a0d8e9d..6ab4c686 100644 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/PriceStrategy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/strategies/PriceStrategy.kt @@ -24,8 +24,8 @@ import java.time.Instant * Base class that can be extended by strategies that are only interested in a single price for an asset and not * other types of actions. */ -abstract class PriceStrategy(private val priceType: String = "DEFAULT", prefix: String = "strategy.") : - RecordingStrategy(prefix) { +abstract class PriceStrategy(private val priceType: String = "DEFAULT") : + Strategy { override fun generate(event: Event): List { val signals = mutableListOf() diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/RecordingStrategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/RecordingStrategy.kt deleted file mode 100644 index be5de389..00000000 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/RecordingStrategy.kt +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright 2020-2024 Neural Layer - * - * 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 - * - * https://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.roboquant.strategies - -/** - * Recording strategy allows subclasses to record metrics during their processing. With the [recording] flag you can - * enable or disable the actual recording of the metrics. - * - * @property prefix Prefix to use when logging a metric, default is "strategy." - * @property recording Should metrics be recorded or not. Some strategies can record a lot of metrics, so this disables - * that recording and as a consequence might result in faster runs and/or use less memory usage. - * - */ -abstract class RecordingStrategy(private val prefix: String = "strategy.", var recording: Boolean = false) : Strategy { - - private val metrics = mutableMapOf() - - /** - * Return the recorded metrics. After this method has been invoked, the metrics are also cleared, so calling this - * method twice in a row won't return the same result. - */ - override fun getMetrics(): Map { - val result = metrics.toMap() - metrics.clear() - return result - } - - /** - * Record a new metric with the given [key] and [value]. If there is already a metric recorded with the same key, - * it will be overridden. - */ - fun record(key: String, value: Double) { - if (!recording) return - metrics["$prefix$key"] = value - } - - /** - * Any recorded metric will be cleared. - */ - override fun reset() { - metrics.clear() - } -} - diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/SingleAssetStrategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/SingleAssetStrategy.kt index 374cb5d1..a4fed1a3 100644 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/SingleAssetStrategy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/strategies/SingleAssetStrategy.kt @@ -30,8 +30,7 @@ import java.time.Instant */ abstract class SingleAssetStrategy( protected val asset: Asset, - prefix: String = "strategy.${asset.symbol}." -) : RecordingStrategy(prefix = prefix) { +) : Strategy { override fun generate(event: Event): List { val result = mutableListOf() diff --git a/roboquant/src/main/kotlin/org/roboquant/strategies/Strategy.kt b/roboquant/src/main/kotlin/org/roboquant/strategies/Strategy.kt index e103e09b..c4613c6e 100644 --- a/roboquant/src/main/kotlin/org/roboquant/strategies/Strategy.kt +++ b/roboquant/src/main/kotlin/org/roboquant/strategies/Strategy.kt @@ -39,14 +39,6 @@ interface Strategy { */ fun generate(event: Event): List - /** - * This will be invoked at each step in a run and provides the implementation with the opportunity to log additional - * information. The default implementation is to return an empty map. - * - * This map should NOT be mutated after it has been returned by this method. - */ - fun getMetrics(): Map = emptyMap() - /** * Reset the state of the component to its initial state. The default implementation is to take no action. */ diff --git a/roboquant/src/test/kotlin/org/roboquant/brokers/sim/SimBrokerTest.kt b/roboquant/src/test/kotlin/org/roboquant/brokers/sim/SimBrokerTest.kt index 274aa02c..cb3fc360 100644 --- a/roboquant/src/test/kotlin/org/roboquant/brokers/sim/SimBrokerTest.kt +++ b/roboquant/src/test/kotlin/org/roboquant/brokers/sim/SimBrokerTest.kt @@ -39,7 +39,6 @@ internal class SimBrokerTest { fun defaults() { val broker = SimBroker() assertEquals(Wallet(1_000_000.USD), broker.initialDeposit) - assertTrue(broker.getMetrics().isEmpty()) val account = broker.sync() assertEquals(USD, account.baseCurrency) assertEquals(Wallet(1_000_000.USD), account.cash) @@ -65,9 +64,6 @@ internal class SimBrokerTest { assertEquals(Wallet(100_000.USD), broker2.initialDeposit) assertEquals(USD, broker2.sync().baseCurrency) - val metrics = broker.getMetrics() - assertTrue(metrics.isEmpty()) - // broker2.refresh() assertEquals(Wallet(100_000.USD), broker2.initialDeposit) } diff --git a/roboquant/src/test/kotlin/org/roboquant/policies/FlexPolicyTest.kt b/roboquant/src/test/kotlin/org/roboquant/policies/FlexPolicyTest.kt index f84f7812..332f2be1 100644 --- a/roboquant/src/test/kotlin/org/roboquant/policies/FlexPolicyTest.kt +++ b/roboquant/src/test/kotlin/org/roboquant/policies/FlexPolicyTest.kt @@ -26,7 +26,6 @@ import org.roboquant.orders.* import org.roboquant.strategies.Signal import java.time.Instant import kotlin.test.Test -import kotlin.test.assertContains import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -42,20 +41,6 @@ internal class FlexPolicyTest { assertTrue(orders.isEmpty()) } - @Test - fun recording() { - val policy = FlexPolicy() - policy.enableMetrics = true - val signals = mutableListOf() - val event = Event(Instant.now(), emptyList()) - val account = InternalAccount(Currency.USD).toAccount() - policy.act(signals, account, event) - val metrics = policy.getMetrics() - assertTrue(metrics.isNotEmpty()) - assertContains(metrics, "policy.actions") - assertContains(metrics, "policy.signals") - assertContains(metrics, "policy.orders.new") - } @Test fun order3() { diff --git a/roboquant/src/test/kotlin/org/roboquant/policies/TestPolicyTest.kt b/roboquant/src/test/kotlin/org/roboquant/policies/TestPolicyTest.kt index 1ffc007d..fce0233e 100644 --- a/roboquant/src/test/kotlin/org/roboquant/policies/TestPolicyTest.kt +++ b/roboquant/src/test/kotlin/org/roboquant/policies/TestPolicyTest.kt @@ -42,7 +42,6 @@ internal class TestPolicyTest { val account = InternalAccount(Currency.USD).toAccount() val orders = policy.act(emptyList(), account, Event.empty()) assertTrue(orders.isEmpty()) - assertTrue(policy.getMetrics().isEmpty()) } @Test @@ -55,7 +54,6 @@ internal class TestPolicyTest { val account = InternalAccount(Currency.USD).toAccount() val orders = policy.act(signals, account, event) assertTrue(orders.first() is MarketOrder) - assertTrue(policy.getMetrics().isEmpty()) } val signals = listOf(Signal(TestData.usStock(), 0.0)) diff --git a/roboquant/src/test/kotlin/org/roboquant/strategies/CombinedStrategyTest.kt b/roboquant/src/test/kotlin/org/roboquant/strategies/CombinedStrategyTest.kt index 60dd0dcb..59d53162 100644 --- a/roboquant/src/test/kotlin/org/roboquant/strategies/CombinedStrategyTest.kt +++ b/roboquant/src/test/kotlin/org/roboquant/strategies/CombinedStrategyTest.kt @@ -30,9 +30,6 @@ internal class CombinedStrategyTest { return emptyList() } - override fun getMetrics(): Map { - return emptyMap() - } } @@ -46,7 +43,6 @@ internal class CombinedStrategyTest { val signals = mutableListOf() for (event in TestData.events(10)) signals += s.generate(event) assertTrue(signals.isEmpty()) - assertTrue(s.getMetrics().isEmpty()) } } diff --git a/roboquant/src/test/kotlin/org/roboquant/strategies/EMAStrategyTest.kt b/roboquant/src/test/kotlin/org/roboquant/strategies/EMAStrategyTest.kt index 2f12afaa..2989b778 100644 --- a/roboquant/src/test/kotlin/org/roboquant/strategies/EMAStrategyTest.kt +++ b/roboquant/src/test/kotlin/org/roboquant/strategies/EMAStrategyTest.kt @@ -17,27 +17,19 @@ package org.roboquant.strategies import kotlinx.coroutines.runBlocking -import kotlin.test.Test import org.roboquant.Roboquant import org.roboquant.TestData import org.roboquant.loggers.MemoryLogger -import org.roboquant.loggers.latestRun +import kotlin.test.Test import kotlin.test.assertNotEquals -import kotlin.test.assertTrue internal class EMAStrategyTest { @Test fun simpleTest() = runBlocking { val strategy = EMAStrategy() - strategy.recording = true val roboquant = Roboquant(strategy, logger = MemoryLogger(false)) roboquant.run(TestData.feed, name = "test") - val names = roboquant.logger.getMetricNames() - - assertTrue(names.isNotEmpty()) - val metrics = roboquant.logger.getMetric(names.first()).latestRun() - assertTrue(metrics.isNotEmpty()) } @Test @@ -45,7 +37,6 @@ internal class EMAStrategyTest { val strategy1 = EMAStrategy.PERIODS_5_15 val strategy2 = EMAStrategy.PERIODS_12_26 val strategy3 = EMAStrategy.PERIODS_50_200 - assertTrue(!strategy1.recording) assertNotEquals(strategy1, strategy2) assertNotEquals(strategy2, strategy3) }