Implement a custom HystrixPropertiesStrategy plugin

.travis.yml

@@ -14,4 +14,4 @@ before_script:
   - psql -c "CREATE USER octoparts_app WITH PASSWORD '';" -U postgres
   - psql -c "GRANT ALL PRIVILEGES ON DATABASE octoparts_test to octoparts_app;" -U postgres
 
-script: "sbt coveralls"
+script: "sbt coveralls test"

app/com/m3/octoparts/Global.scala

@@ -7,10 +7,11 @@ import _root_.controllers.ControllersModule
 import com.kenshoo.play.metrics.MetricsFilter
 import com.m3.octoparts.cache.CacheModule
 import com.m3.octoparts.http.HttpModule
-import com.m3.octoparts.hystrix.{ HystrixMetricsLogger, HystrixModule }
+import com.m3.octoparts.hystrix.{ CachelessHystrixPropertiesStrategy, HystrixMetricsLogger, HystrixModule }
 import com.m3.octoparts.logging.PartRequestLogger
 import com.beachape.logging.LTSVLogger
 import com.m3.octoparts.repository.RepositoriesModule
+import com.netflix.hystrix.strategy.HystrixPlugins
 import com.typesafe.config.ConfigFactory
 import com.wordnik.swagger.config.{ ConfigFactory => SwaggerConfigFactory }
 import com.wordnik.swagger.model.ApiInfo
@@ -22,6 +23,7 @@ import scaldi.play.ScaldiSupport
 
 import scala.collection.concurrent.TrieMap
 import scala.concurrent.duration._
+import scala.util.control.NonFatal
 
 object Global extends WithFilters(MetricsFilter) with ScaldiSupport {
 
@@ -80,8 +82,8 @@ object Global extends WithFilters(MetricsFilter) with ScaldiSupport {
   }
 
   override def onStart(app: Application) = {
+    setHystrixPropertiesStrategy(app)
     super.onStart(app)
-
     startPeriodicTasks(app)
   }
 
@@ -97,4 +99,29 @@ object Global extends WithFilters(MetricsFilter) with ScaldiSupport {
       HystrixMetricsLogger.logHystrixMetrics()
     }
   }
+
+  /**
+   * Tries to set the Hystrix properties strategy to CachelessHystrixPropertiesStrategy
+   *
+   * Resist the temptation to do a HystrixPlugins.getInstance().getPropertiesStrategy first to do
+   * checking, as that actually also sets the strategy if it isn't already set.
+   */
+  def setHystrixPropertiesStrategy(app: Application): Unit = {
+    // If it's defined, we don't need to set anything
+    if (sys.props.get("hystrix.plugin.HystrixPropertiesStrategy.implementation").isEmpty) {
+      LTSVLogger.warn("-Dhystrix.plugin.HystrixPropertiesStrategy.implementation is not set. It should be" -> "com.m3.octoparts.hystrix.CachelessHystrixPropertiesStrategy")
+      try {
+        HystrixPlugins.getInstance().registerPropertiesStrategy(new CachelessHystrixPropertiesStrategy)
+      } catch {
+        case NonFatal(e) => {
+          val currentStrategy = HystrixPlugins.getInstance().getPropertiesStrategy.getClass
+          if (currentStrategy != classOf[CachelessHystrixPropertiesStrategy]) {
+            LTSVLogger.error(e, "Current Hystrix Properties Strategy:" -> currentStrategy)
+            if (Play.mode(app) != Mode.Test)
+              sys.error("Tried but failed to set CachelessHystrixPropertiesStrategy as HystrixPropertiesStrategy")
+          }
+        }
+      }
+    }
+  }
 }

app/com/m3/octoparts/cache/PartResponseCachingSupport.scala

@@ -63,7 +63,7 @@ trait PartResponseCachingSupport extends PartRequestServiceBase with Logging {
 
   private def onCacheFailure(ci: HttpPartConfig,
                              partRequestInfo: PartRequestInfo,
-                             params: Map[ShortPartParam, String]): PartialFunction[Throwable, Future[PartResponse]] = {
+                             params: Map[ShortPartParam, Seq[String]]): PartialFunction[Throwable, Future[PartResponse]] = {
     case ce: CacheException => {
       ce.getCause match {
         case te: shade.TimeoutException =>

app/com/m3/octoparts/hystrix/CachelessHystrixPropertiesStrategy.scala

@@ -0,0 +1,13 @@
+package com.m3.octoparts.hystrix
+
+import com.netflix.hystrix.{ HystrixCommandKey, HystrixCommandProperties }
+import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy
+
+/**
+ * Custom [[HystrixPropertiesStrategy]] implementation where  getCommandPropertiesCacheKey is overridden
+ * to return null so that [[com.netflix.hystrix.strategy.properties.HystrixPropertiesFactory]] will always
+ * generate a new [[HystrixCommandProperties]] for each new [[com.netflix.hystrix.HystrixCommand]] instantiation
+ */
+class CachelessHystrixPropertiesStrategy extends HystrixPropertiesStrategy {
+  override def getCommandPropertiesCacheKey(commandKey: HystrixCommandKey, builder: HystrixCommandProperties.Setter): String = null
+}

project/Build.scala

@@ -72,6 +72,7 @@ object OctopartsBuild extends Build {
       sonatypeSettings ++
       coverallsSettings ++
       Seq(
+        javaOptions += "-Dhystrix.plugin.HystrixPropertiesStrategy.implementation=com.m3.octoparts.hystrix.CachelessHystrixPropertiesStrategy",
         publishArtifact := false,
         libraryDependencies ++= Seq(
           // Logging

test/com/m3/octoparts/hystrix/CachelessHystrixPropertiesStrategySpec.scala

@@ -0,0 +1,38 @@
+package com.m3.octoparts.hystrix
+
+import com.netflix.hystrix.strategy.HystrixPlugins
+import com.netflix.hystrix.strategy.properties.HystrixPropertiesFactory
+import com.netflix.hystrix.{ HystrixCommandProperties, HystrixCommandKey }
+import org.scalatest.{ Matchers, FunSpec }
+
+class CachelessHystrixPropertiesStrategySpec extends FunSpec with Matchers {
+
+  val subject = new CachelessHystrixPropertiesStrategy
+  val commandKey = HystrixCommandKey.Factory.asKey("hello")
+  val commandProps = HystrixCommandProperties.Setter()
+  describe("getCommandPropertiesCacheKey") {
+    it("should return null") {
+      val r = subject.getCommandPropertiesCacheKey(commandKey, commandProps)
+      r should be(null)
+    }
+  }
+
+  // The following works if this test is run by itself, but
+  describe("after registering with HystrixPlugins") {
+
+    it("should allow HystrixPropertiesFactory.getCommandProperties to instantiate different HystrixCommandProperties for the same command key") {
+      if (HystrixPlugins.getInstance().getPropertiesStrategy.getClass != subject.getClass) {
+        fail("HystrixPlugins.getPropertiesStrategy did not return CachelessHystrixPropertiesStrategy")
+      }
+      val properties1 = HystrixPropertiesFactory.getCommandProperties(
+        commandKey,
+        HystrixCommandProperties.Setter().withExecutionIsolationThreadTimeoutInMilliseconds(300))
+      val properties2 = HystrixPropertiesFactory.getCommandProperties(
+        commandKey,
+        HystrixCommandProperties.Setter().withExecutionIsolationThreadTimeoutInMilliseconds(600))
+      properties1.executionIsolationThreadTimeoutInMilliseconds.get should be(300)
+      properties2.executionIsolationThreadTimeoutInMilliseconds.get should be(600)
+    }
+  }
+
+}