result = new ArrayList<>();
+ for (String contactPoint : contactPoints.split(",", 100)) {
+ HostAndPort parsed = HostAndPort.fromString(contactPoint, 9042);
+ result.add(new InetSocketAddress(parsed.getHost(), parsed.getPort()));
+ }
+ return result;
+ }
+}
diff --git a/zipkin-server/storage-cassandra/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider b/zipkin-server/storage-cassandra/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider
new file mode 100755
index 00000000000..38538a46d12
--- /dev/null
+++ b/zipkin-server/storage-cassandra/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider
@@ -0,0 +1,19 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+#
+#
+
+zipkin.server.storage.cassandra.CassandraProvider
\ No newline at end of file
diff --git a/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/ApplicationConfigLoader.java b/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/ApplicationConfigLoader.java
new file mode 100644
index 00000000000..fa536c3c099
--- /dev/null
+++ b/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/ApplicationConfigLoader.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2015-2023 The OpenZipkin Authors
+ *
+ * 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 zipkin.server.storage.cassandra;
+
+import org.apache.skywalking.oap.server.library.module.ApplicationConfiguration;
+import org.apache.skywalking.oap.server.library.module.ProviderNotFoundException;
+import org.apache.skywalking.oap.server.library.util.CollectionUtils;
+import org.apache.skywalking.oap.server.library.util.PropertyPlaceholderHelper;
+import org.apache.skywalking.oap.server.library.util.ResourceUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.FileNotFoundException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * Initialize collector settings with following sources. Use application.yml as primary setting, and fix missing setting
+ * by default settings in application-default.yml.
+ *
+ * At last, override setting by system.properties and system.envs if the key matches moduleName.provideName.settingKey.
+ */
+public class ApplicationConfigLoader {
+ static final Logger log = LoggerFactory.getLogger(ApplicationConfigLoader.class.getName());
+
+ private static final String DISABLE_SELECTOR = "-";
+ private static final String SELECTOR = "selector";
+
+ private final Yaml yaml = new Yaml();
+
+ public ApplicationConfiguration load() {
+ ApplicationConfiguration configuration = new ApplicationConfiguration();
+ this.loadConfig(configuration);
+ this.overrideConfigBySystemEnv(configuration);
+ return configuration;
+ }
+
+ @SuppressWarnings("unchecked")
+ private void loadConfig(ApplicationConfiguration configuration) {
+ try {
+ Reader applicationReader = ResourceUtils.read("application.yml");
+ Map> moduleConfig = yaml.loadAs(applicationReader, Map.class);
+ if (CollectionUtils.isNotEmpty(moduleConfig)) {
+ selectConfig(moduleConfig);
+ moduleConfig.forEach((moduleName, providerConfig) -> {
+ if (providerConfig.size() > 0) {
+ log.info("Get a module define from application.yml, module name: {}", moduleName);
+ ApplicationConfiguration.ModuleConfiguration moduleConfiguration = configuration.addModule(
+ moduleName);
+ providerConfig.forEach((providerName, config) -> {
+ log.info(
+ "Get a provider define belong to {} module, provider name: {}", moduleName,
+ providerName
+ );
+ final Map propertiesConfig = (Map) config;
+ final Properties properties = new Properties();
+ if (propertiesConfig != null) {
+ propertiesConfig.forEach((propertyName, propertyValue) -> {
+ if (propertyValue instanceof Map) {
+ Properties subProperties = new Properties();
+ ((Map) propertyValue).forEach((key, value) -> {
+ subProperties.put(key, value);
+ replacePropertyAndLog(key, value, subProperties, providerName);
+ });
+ properties.put(propertyName, subProperties);
+ } else {
+ properties.put(propertyName, propertyValue);
+ replacePropertyAndLog(propertyName, propertyValue, properties, providerName);
+ }
+ });
+ }
+ moduleConfiguration.addProviderConfiguration(providerName, properties);
+ });
+ } else {
+ log.warn(
+ "Get a module define from application.yml, but no provider define, use default, module name: {}",
+ moduleName
+ );
+ }
+ });
+ }
+ } catch (FileNotFoundException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private void replacePropertyAndLog(final String propertyName, final Object propertyValue, final Properties target,
+ final Object providerName) {
+ final String valueString = PropertyPlaceholderHelper.INSTANCE
+ .replacePlaceholders(String.valueOf(propertyValue), target);
+ if (valueString.trim().length() == 0) {
+ target.replace(propertyName, valueString);
+ log.info("Provider={} config={} has been set as an empty string", providerName, propertyName);
+ } else {
+ // Use YAML to do data type conversion.
+ final Object replaceValue = convertValueString(valueString);
+ if (replaceValue != null) {
+ target.replace(propertyName, replaceValue);
+ }
+ }
+ }
+
+ private Object convertValueString(String valueString) {
+ try {
+ Object replaceValue = yaml.load(valueString);
+ if (replaceValue instanceof String || replaceValue instanceof Integer || replaceValue instanceof Long || replaceValue instanceof Boolean || replaceValue instanceof ArrayList) {
+ return replaceValue;
+ } else {
+ return valueString;
+ }
+ } catch (Exception e) {
+ log.warn("yaml convert value type error, use origin values string. valueString={}", valueString, e);
+ return valueString;
+ }
+ }
+
+ private void overrideConfigBySystemEnv(ApplicationConfiguration configuration) {
+ for (Map.Entry prop : System.getProperties().entrySet()) {
+ overrideModuleSettings(configuration, prop.getKey().toString(), prop.getValue().toString());
+ }
+ }
+
+ private void selectConfig(final Map> moduleConfiguration) {
+ Iterator>> moduleIterator = moduleConfiguration.entrySet().iterator();
+ while (moduleIterator.hasNext()) {
+ Map.Entry> entry = moduleIterator.next();
+ final String moduleName = entry.getKey();
+ final Map providerConfig = entry.getValue();
+ if (!providerConfig.containsKey(SELECTOR)) {
+ continue;
+ }
+ final String selector = (String) providerConfig.get(SELECTOR);
+ final String resolvedSelector = PropertyPlaceholderHelper.INSTANCE.replacePlaceholders(
+ selector, System.getProperties()
+ );
+ providerConfig.entrySet().removeIf(e -> !resolvedSelector.equals(e.getKey()));
+
+ if (!providerConfig.isEmpty()) {
+ continue;
+ }
+
+ if (!DISABLE_SELECTOR.equals(resolvedSelector)) {
+ throw new ProviderNotFoundException(
+ "no provider found for module " + moduleName + ", " +
+ "if you're sure it's not required module and want to remove it, " +
+ "set the selector to -"
+ );
+ }
+
+ // now the module can be safely removed
+ moduleIterator.remove();
+ log.info("Remove module {} without any provider", moduleName);
+ }
+ }
+
+ private void overrideModuleSettings(ApplicationConfiguration configuration, String key, String value) {
+ int moduleAndConfigSeparator = key.indexOf('.');
+ if (moduleAndConfigSeparator <= 0) {
+ return;
+ }
+ String moduleName = key.substring(0, moduleAndConfigSeparator);
+ String providerSettingSubKey = key.substring(moduleAndConfigSeparator + 1);
+ ApplicationConfiguration.ModuleConfiguration moduleConfiguration = configuration.getModuleConfiguration(
+ moduleName);
+ if (moduleConfiguration == null) {
+ return;
+ }
+ int providerAndConfigSeparator = providerSettingSubKey.indexOf('.');
+ if (providerAndConfigSeparator <= 0) {
+ return;
+ }
+ String providerName = providerSettingSubKey.substring(0, providerAndConfigSeparator);
+ String settingKey = providerSettingSubKey.substring(providerAndConfigSeparator + 1);
+ if (!moduleConfiguration.has(providerName)) {
+ return;
+ }
+ Properties providerSettings = moduleConfiguration.getProviderConfiguration(providerName);
+ if (!providerSettings.containsKey(settingKey)) {
+ return;
+ }
+ Object originValue = providerSettings.get(settingKey);
+ Class type = originValue.getClass();
+ if (type.equals(int.class) || type.equals(Integer.class))
+ providerSettings.put(settingKey, Integer.valueOf(value));
+ else if (type.equals(String.class))
+ providerSettings.put(settingKey, value);
+ else if (type.equals(long.class) || type.equals(Long.class))
+ providerSettings.put(settingKey, Long.valueOf(value));
+ else if (type.equals(boolean.class) || type.equals(Boolean.class)) {
+ providerSettings.put(settingKey, Boolean.valueOf(value));
+ } else {
+ return;
+ }
+
+ log.info(
+ "The setting has been override by key: {}, value: {}, in {} provider of {} module through {}", settingKey,
+ value, providerName, moduleName, "System.properties"
+ );
+ }
+}
diff --git a/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/CassandraExtension.java b/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/CassandraExtension.java
new file mode 100644
index 00000000000..3209158d350
--- /dev/null
+++ b/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/CassandraExtension.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2015-2023 The OpenZipkin Authors
+ *
+ * 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 zipkin.server.storage.cassandra;
+
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.opentest4j.TestAbortedException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.InternetProtocol;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.testcontainers.containers.wait.strategy.Wait;
+
+import java.time.Duration;
+
+import static org.testcontainers.utility.DockerImageName.parse;
+
+public class CassandraExtension implements BeforeAllCallback, AfterAllCallback {
+ static final Logger LOGGER = LoggerFactory.getLogger(CassandraExtension.class);
+ static final int CASSANDRA_PORT = 9042;
+
+ final CassandraContainer container = new CassandraContainer();
+
+ @Override
+ public void afterAll(ExtensionContext context) throws Exception {
+ container.stop();
+ }
+
+ @Override
+ public void beforeAll(ExtensionContext context) throws Exception {
+ if (context.getRequiredTestClass().getEnclosingClass() != null) {
+ // Only run once in outermost scope.
+ return;
+ }
+
+ container.start();
+ LOGGER.info("Using bootstrapServer " + bootstrapServer());
+ }
+
+ String bootstrapServer() {
+ return container.getHost() + ":" + container.getMappedPort(CASSANDRA_PORT);
+ }
+
+ static final class CassandraContainer extends GenericContainer {
+ CassandraContainer() {
+ super(parse("cassandra:4.1.3"));
+ if ("true".equals(System.getProperty("docker.skip"))) {
+ throw new TestAbortedException("${docker.skip} == true");
+ }
+ waitStrategy = Wait.forSuccessfulCommand("cqlsh -e \"describe keyspaces\"").withStartupTimeout(Duration.ofMinutes(5));
+ addFixedExposedPort(CASSANDRA_PORT, CASSANDRA_PORT, InternetProtocol.TCP);
+ withLogConsumer(new Slf4jLogConsumer(LOGGER));
+ }
+ }
+}
diff --git a/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/ITCassandraStorage.java b/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/ITCassandraStorage.java
new file mode 100644
index 00000000000..04b4bdc628b
--- /dev/null
+++ b/zipkin-server/storage-cassandra/src/test/java/zipkin/server/storage/cassandra/ITCassandraStorage.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2015-2023 The OpenZipkin Authors
+ *
+ * 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 zipkin.server.storage.cassandra;
+
+import org.apache.skywalking.oap.server.core.analysis.manual.searchtag.TagType;
+import org.apache.skywalking.oap.server.core.query.enumeration.Step;
+import org.apache.skywalking.oap.server.core.query.input.Duration;
+import org.apache.skywalking.oap.server.core.storage.StorageModule;
+import org.apache.skywalking.oap.server.core.storage.query.ITagAutoCompleteQueryDAO;
+import org.apache.skywalking.oap.server.core.storage.query.IZipkinQueryDAO;
+import org.apache.skywalking.oap.server.library.module.ModuleConfigException;
+import org.apache.skywalking.oap.server.library.module.ModuleManager;
+import org.apache.skywalking.oap.server.library.module.ModuleNotFoundException;
+import org.apache.skywalking.oap.server.library.module.ModuleStartException;
+import org.apache.skywalking.oap.server.receiver.zipkin.ZipkinReceiverConfig;
+import org.apache.skywalking.oap.server.receiver.zipkin.trace.SpanForward;
+import org.joda.time.DateTime;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.junit.jupiter.MockitoExtension;
+import zipkin2.Span;
+import zipkin2.TestObjects;
+import zipkin2.storage.QueryRequest;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@Timeout(120)
+@ExtendWith(MockitoExtension.class)
+public class ITCassandraStorage {
+ @RegisterExtension
+ CassandraExtension cassandra = new CassandraExtension();
+
+ private final ModuleManager moduleManager = new ModuleManager();
+ private SpanForward forward;
+ private ITagAutoCompleteQueryDAO tagAutoCompleteQueryDAO;
+ private IZipkinQueryDAO zipkinQueryDAO;
+ @BeforeAll
+ public void setup() throws ModuleNotFoundException, ModuleConfigException, ModuleStartException {
+ final ApplicationConfigLoader loader = new ApplicationConfigLoader();
+ moduleManager.init(loader.load());
+ final ZipkinReceiverConfig config = new ZipkinReceiverConfig();
+ config.setSearchableTracesTags("http.path");
+ this.forward = new SpanForward(config, moduleManager);
+ this.tagAutoCompleteQueryDAO = moduleManager.find(StorageModule.NAME).provider().getService(ITagAutoCompleteQueryDAO.class);
+ this.zipkinQueryDAO = moduleManager.find(StorageModule.NAME).provider().getService(IZipkinQueryDAO.class);
+ }
+
+ @Test
+ public void test() throws InterruptedException, IOException {
+ final List traceSpans = TestObjects.newTrace("");
+ forward.send(traceSpans);
+ Thread.sleep(TimeUnit.SECONDS.toMillis(5));
+
+ // service names
+ final List serviceNames = zipkinQueryDAO.getServiceNames();
+ Assert.assertEquals(2, serviceNames.size());
+ Assert.assertTrue(serviceNames.contains(TestObjects.FRONTEND.serviceName()));
+ Assert.assertTrue(serviceNames.contains(TestObjects.BACKEND.serviceName()));
+
+ // remote service names
+ final List remoteServiceNames = zipkinQueryDAO.getRemoteServiceNames(TestObjects.FRONTEND.serviceName());
+ Assert.assertEquals(1, remoteServiceNames.size());
+ Assert.assertEquals(TestObjects.BACKEND.serviceName(), remoteServiceNames.get(0));
+
+ // span names
+ final List spanNames = zipkinQueryDAO.getSpanNames(TestObjects.BACKEND.serviceName());
+ Assert.assertEquals(2, spanNames.size());
+ Assert.assertTrue(spanNames.contains("query"));
+ Assert.assertTrue(spanNames.contains("get"));
+
+ // search traces
+ final QueryRequest query = QueryRequest.newBuilder()
+ .lookback(86400000L)
+ .endTs(System.currentTimeMillis())
+ .minDuration(1000L)
+ .limit(10).build();
+ Duration duration = new Duration();
+ duration.setStep(Step.SECOND);
+ DateTime endTime = new DateTime(query.endTs());
+ DateTime startTime = endTime.minus(org.joda.time.Duration.millis(query.lookback()));
+ duration.setStart(startTime.toString("yyyy-MM-dd HHmmss"));
+ duration.setEnd(endTime.toString("yyyy-MM-dd HHmmss"));
+ final List> traces = zipkinQueryDAO.getTraces(query, duration);
+ Assert.assertEquals(1, traces.size());
+ final List needsSpans = traceSpans.stream().filter(s -> s.duration() > 1000L).collect(Collectors.toList());
+ Assert.assertEquals(needsSpans.size(), traces.get(0).size());
+ for (Span needSpan : needsSpans) {
+ Assert.assertTrue(traces.get(0).stream().anyMatch(needSpan::equals));
+ }
+
+ // get trace
+ final List trace = zipkinQueryDAO.getTrace(traceSpans.get(0).traceId());
+ Assert.assertEquals(traceSpans.size(), trace.size());
+ for (Span span : traceSpans) {
+ Assert.assertTrue(trace.stream().anyMatch(span::equals));
+ }
+
+ final Set keys = tagAutoCompleteQueryDAO.queryTagAutocompleteKeys(TagType.ZIPKIN, 10, duration);
+ Assert.assertEquals(1, keys.size());
+ Assert.assertTrue(keys.contains("http.path"));
+
+ final Set values = tagAutoCompleteQueryDAO.queryTagAutocompleteValues(TagType.ZIPKIN, "http.path", 10, duration);
+ Assert.assertEquals(1, values.size());
+ Assert.assertTrue(values.contains("/api"));
+ }
+
+}
diff --git a/zipkin-server/storage-cassandra/src/test/resources/application.yml b/zipkin-server/storage-cassandra/src/test/resources/application.yml
new file mode 100644
index 00000000000..92458620a68
--- /dev/null
+++ b/zipkin-server/storage-cassandra/src/test/resources/application.yml
@@ -0,0 +1,66 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+core:
+ selector: zipkin
+ zipkin:
+ # The max length of service + instance names should be less than 200
+ serviceNameMaxLength: ${ZIPKIN_SERVICE_NAME_MAX_LENGTH:70}
+ # The period(in seconds) of refreshing the service cache. Default value is 10s.
+ serviceCacheRefreshInterval: ${ZIPKIN_SERVICE_CACHE_REFRESH_INTERVAL:10}
+ instanceNameMaxLength: ${ZIPKIN_INSTANCE_NAME_MAX_LENGTH:70}
+ # The max length of service + endpoint names should be less than 240
+ endpointNameMaxLength: ${ZIPKIN_ENDPOINT_NAME_MAX_LENGTH:150}
+ recordDataTTL: ${ZIPKIN_CORE_RECORD_DATA_TTL:3} # Unit is day
+ metricsDataTTL: ${ZIPKIN_CORE_METRICS_DATA_TTL:7} # Unit is day
+ # The period of L1 aggregation flush to L2 aggregation. Unit is ms.
+ l1FlushPeriod: ${ZIPKIN_CORE_L1_AGGREGATION_FLUSH_PERIOD:500}
+ # The threshold of session time. Unit is ms. Default value is 70s.
+ storageSessionTimeout: ${ZIPKIN_CORE_STORAGE_SESSION_TIMEOUT:70000}
+ # Defines a set of span tag keys which are searchable.
+ # The max length of key=value should be less than 256 or will be dropped.
+ searchableTracesTags: ${ZIPKIN_SEARCHABLE_TAG_KEYS:http.method}
+ # The trace sample rate precision is 1/10000, should be between 0 and 10000
+ traceSampleRate: ${ZIPKIN_SAMPLE_RATE:10000}
+ # The number of threads used to prepare metrics data to the storage.
+ prepareThreads: ${ZIPKIN_PREPARE_THREADS:2}
+ # The period of doing data persistence. Unit is second.Default value is 25s
+ persistentPeriod: ${ZIPKIN_PERSISTENT_PERIOD:1}
+
+storage:
+ selector: ${ZIPKIN_STORAGE:cassandra}
+ cassandra:
+ keyspace: ${ZIPKIN_STORAGE_CASSANDRA_KEYSPACE:zipkin}
+ # Comma separated list of host addresses part of Cassandra cluster. Ports default to 9042 but you can also specify a custom port with 'host:port'.
+ contactPoints: ${ZIPKIN_STORAGE_CASSANDRA_CONTACT_POINTS:localhost}
+ # Name of the datacenter that will be considered "local" for load balancing.
+ localDc: ${ZIPKIN_STORAGE_CASSANDRA_LOCAL_DC:datacenter1}
+ # Will throw an exception on startup if authentication fails.
+ username: ${ZIPKIN_STORAGE_CASSANDRA_USERNAME:}
+ password: ${ZIPKIN_STORAGE_CASSANDRA_PASSWORD:}
+ # Max pooled connections per datacenter-local host.
+ maxConnections: ${ZIPKIN_STORAGE_CASSANDRA_MAX_CONNECTIONS:8}
+ # Using ssl for connection, rely on Keystore
+ use-ssl: ${ZIPKIN_STORAGE_CASSANDRA_USE_SSL:false}
+ maxSizeOfBatchCql: ${ZIPKIN_STORAGE_CASSANDRA_MAX_SIZE_OF_BATCH_CQL:2000}
+ asyncBatchPersistentPoolSize: ${ZIPKIN_STORAGE_CASSANDRA_ASYNC_BATCH_PERSISTENT_POOL_SIZE:4}
+
+telemetry:
+ selector: ${ZIPKIN_TELEMETRY:none}
+ none:
+
+cluster:
+ selector: standalone
+ standalone:
\ No newline at end of file
diff --git a/zipkin-server/storage-cassandra/src/test/resources/log4j2.xml b/zipkin-server/storage-cassandra/src/test/resources/log4j2.xml
new file mode 100644
index 00000000000..9340cc127e9
--- /dev/null
+++ b/zipkin-server/storage-cassandra/src/test/resources/log4j2.xml
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+