From 5b7d1cb4ee53b390c05f73bd40b5b99bf5a7dd79 Mon Sep 17 00:00:00 2001 From: Ankur Shrivastava Date: Fri, 17 Apr 2026 15:02:30 +0800 Subject: [PATCH 1/5] docs: replace hystrix references with executor hook and failsafe-go examples Update all 5 pages that reference hystrix to document the new executor-based resilience API (interceptors.SetDefaultExecutor): - integrations.md: replace Hystrix-Go section with Circuit Breaker / Resilience section including code examples (simple CB, per-method, disable, excluded errors) - howto/Metrics.md: replace Hystrix Metrics section with Circuit Breaker Metrics showing failsafe-go event listener pattern - FAQ.md: update hystrixprometheus answer to point to executor API - Packages.md: mark hystrixprometheus as "will be archived in v1" - index.md: update features table to reference resilience executor hook --- FAQ.md | 4 +-- Index.md | 2 +- Packages.md | 4 +-- howto/Metrics.md | 36 ++++++++------------ integrations.md | 85 +++++++++++++++++++++++++++++++++++++++++------- 5 files changed, 92 insertions(+), 39 deletions(-) diff --git a/FAQ.md b/FAQ.md index 5bd9a1b..de712d6 100644 --- a/FAQ.md +++ b/FAQ.md @@ -121,9 +121,9 @@ See [Custom HTTP Routes](/howto/APIs/#custom-http-routes) for full examples incl ## Is hystrixprometheus still maintained? -**No.** The `hystrixprometheus` package depends on `afex/hystrix-go`, which is unmaintained. Do not invest in this package for new projects. +**No.** The `hystrixprometheus` package depends on `afex/hystrix-go`, which is unmaintained and will be removed in v1. -For circuit breaking, consider [failsafe-go](https://github.com/failsafe-go/failsafe-go) as an alternative. The client-side interceptors in the `interceptors` package provide retry and circuit breaking functionality that covers most use cases. +ColdBrew now provides a pluggable executor hook (`interceptors.SetDefaultExecutor`) for circuit breaking. Use [failsafe-go](https://github.com/failsafe-go/failsafe-go) as the recommended resilience library. See the [integrations page](/integrations/#circuit-breaker--resilience) for setup examples. ## How do I do cross-package development? diff --git a/Index.md b/Index.md index db6ece6..a4fd241 100644 --- a/Index.md +++ b/Index.md @@ -28,7 +28,7 @@ A Kubernetes-native Go microservice framework for building production-grade gRPC | **gRPC + REST Gateway** | Define your API once in protobuf — get gRPC, REST, and [Swagger docs](/architecture#self-documenting-apis) automatically via [grpc-gateway]. HTTP gateway supports JSON, `application/proto`, and `application/protobuf` [content types](/howto/APIs/#http-content-type) out of the box | | **Structured Logging** | Native [slog] with custom Handler — per-request context fields, trace ID propagation, and typed attrs for zero-boxing performance | | **Distributed Tracing** | [OpenTelemetry] and [New Relic] support with automatic span creation via gRPC stats handlers — traces can be sent to any OTLP-compatible backend including [Jaeger] | -| **Prometheus Metrics** | Built-in request latency, error rate, and circuit breaker metrics at `/metrics` | +| **Prometheus Metrics** | Built-in request latency, error rate metrics at `/metrics`, plus pluggable [resilience executor hook](/integrations/#circuit-breaker--resilience) for circuit breaking | | **Error Tracking** | Stack traces, gRPC status codes, and async notification to [Sentry], Rollbar, or Airbrake | | **Rate Limiting** | Per-pod token bucket rate limiter — disabled by default, pluggable via custom [`ratelimit.Limiter`](https://pkg.go.dev/github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/ratelimit#Limiter) interface for distributed or per-tenant rate limiting. Config: `RATE_LIMIT_PER_SECOND`. See [interceptors howto](/howto/interceptors#rate-limiting) | | **Auth Examples** | JWT and API key authentication interceptor examples in the [cookiecutter template][ColdBrew cookiecutter], built on [go-grpc-middleware auth](https://github.com/grpc-ecosystem/go-grpc-middleware/tree/main/interceptors/auth). See [auth howto](/howto/auth/) | diff --git a/Packages.md b/Packages.md index 25f1726..a04f36b 100644 --- a/Packages.md +++ b/Packages.md @@ -50,8 +50,8 @@ Tracing is a library that provides distributed tracing to Go applications. It of Documentation can be found at [tracing-docs] -## [Hystrix Prometheus] (Deprecated) -hystrixprometheus provides a Prometheus metrics collector for Hystrix (https://github.com/afex/hystrix-go). This package is deprecated as hystrix-go is unmaintained. Consider migrating to [failsafe-go](https://github.com/failsafe-go/failsafe-go). +## [Hystrix Prometheus] (Deprecated — will be archived in v1) +hystrixprometheus provides a Prometheus metrics collector for Hystrix. This package is deprecated as hystrix-go is unmaintained. Use `interceptors.SetDefaultExecutor` with [failsafe-go](https://github.com/failsafe-go/failsafe-go) instead. See [integrations](/integrations/#circuit-breaker--resilience). Documentation can be found at [hystrixprometheus-docs] diff --git a/howto/Metrics.md b/howto/Metrics.md index 9a3ecb1..7ae250b 100644 --- a/howto/Metrics.md +++ b/howto/Metrics.md @@ -3,7 +3,7 @@ layout: default title: "Metrics" parent: "How To" nav_order: 6 -description: "Prometheus and OpenTelemetry metrics in ColdBrew: default runtime metrics, OTLP export, custom counters and histograms, and Hystrix circuit breaker monitoring" +description: "Prometheus and OpenTelemetry metrics in ColdBrew: default runtime metrics, OTLP export, custom counters and histograms, and circuit breaker monitoring" --- ## Table of contents {: .no_toc .text-delta } @@ -136,32 +136,24 @@ Health check, readiness, and server reflection RPCs are bucketed under a generic Both export pipelines use independent metric names and registries, so there is no conflict or double-counting. -## How to use Hystrix Metrics in Prometheus +## Circuit Breaker Metrics -{: .warning } -Hystrix-Go is unmaintained (last updated 2018). Consider migrating to [failsafe-go](https://github.com/failsafe-go/failsafe-go) for circuit breaker functionality. - -[Hystrix Prometheus] is a library that provides a Prometheus metrics collector for [Hystrix-go]. To use it, you can register the collector with the default Prometheus registry: +Circuit breaker metrics are the responsibility of the resilience library you plug into ColdBrew's executor hook. For example, with [failsafe-go](https://github.com/failsafe-go/failsafe-go) you can attach event listeners to track circuit state: ```go - -import ( - metricCollector "github.com/afex/hystrix-go/hystrix/metric_collector" - "github.com/go-coldbrew/hystrixprometheus" - "github.com/prometheus/client_golang/prometheus" -) - -// setupHystrix sets up the hystrix metrics -// This is a workaround for hystrix-go not supporting the prometheus registry -func setupHystrix() { - promC := hystrixprometheus.NewPrometheusCollector("hystrix", nil, prometheus.DefBuckets) - metricCollector.Registry.Register(promC.Collector) -} +cb := circuitbreaker.NewBuilder[any](). + WithFailureThreshold(5). + WithDelay(5 * time.Second). + OnStateChanged(func(e circuitbreaker.StateChangedEvent) { + circuitStateGauge.WithLabelValues(commandName).Set(float64(e.NewState)) + }). + Build() ``` -{: .note .note-info } -If you are using the `go-coldbrew/core` package, you can skip the above step as it will automatically register the collector for you. -See [Hystrix Prometheus] for more details. +ColdBrew's built-in `grpc_client_*` Prometheus metrics (request count, duration, status codes) cover request-level observability automatically. See the [integrations page](/integrations/#circuit-breaker--resilience) for full executor setup examples. + +{: .warning } +**Legacy:** The previous `hystrixprometheus` package and `core.SetupHystrixPrometheus()` are deprecated. Circuit breaker metrics are now managed by your chosen resilience library, not ColdBrew. --- [HTTP port]: https://pkg.go.dev/github.com/go-coldbrew/core/config#readme-type-config diff --git a/integrations.md b/integrations.md index a529fd4..2212eac 100644 --- a/integrations.md +++ b/integrations.md @@ -231,28 +231,89 @@ func main() { } ``` -## Hystrix-Go +## Circuit Breaker / Resilience -{: .warning } -Hystrix-Go (`afex/hystrix-go`) is unmaintained (last updated 2018). Consider migrating to [failsafe-go] for circuit breaker functionality. +ColdBrew provides a pluggable executor hook for client-side resilience (circuit breaking, retries, bulkheading, etc.). You bring your own resilience library — [failsafe-go] is recommended. -[Hystrix-Go] is a Go implementation of the circuit breaker pattern. ColdBrew provides Prometheus metrics integration for Hystrix. +### How it works -### Initialising +Call `interceptors.SetDefaultExecutor` during init to wrap all outbound gRPC calls with your resilience logic. The executor receives the gRPC method name, enabling per-method circuit breakers. -If your app is using [ColdBrew cookiecutter] template, initialisation is done automatically. +```go +import ( + "github.com/failsafe-go/failsafe-go" + "github.com/failsafe-go/failsafe-go/circuitbreaker" + "github.com/go-coldbrew/interceptors" +) + +func init() { + cb := circuitbreaker.NewBuilder[any](). + WithFailureThreshold(5). + WithDelay(5 * time.Second). + WithSuccessThreshold(2). + Build() + + interceptors.SetDefaultExecutor(func(ctx context.Context, method string, fn func(ctx context.Context) error) error { + return failsafe.With[any](cb).WithContext(ctx).Run(func() error { + return fn(ctx) + }) + }) +} +``` -If you are using ColdBrew packages in your app, you need to initialise Hystrix Prometheus manually: +### Per-method circuit breakers -```go -import "github.com/go-coldbrew/core" +For independent circuit breakers per gRPC method (so failures in one method don't trip another): -func main() { - // SetupHystrixPrometheus registers Hystrix metrics with Prometheus - core.SetupHystrixPrometheus() +```go +func init() { + var ( + mu sync.Mutex + breakers = make(map[string]circuitbreaker.CircuitBreaker[any]) + ) + + interceptors.SetDefaultExecutor(func(ctx context.Context, method string, fn func(ctx context.Context) error) error { + mu.Lock() + cb, ok := breakers[method] + if !ok { + cb = circuitbreaker.NewBuilder[any](). + WithFailureThreshold(5). + WithDelay(5 * time.Second). + Build() + breakers[method] = cb + } + mu.Unlock() + + return failsafe.With[any](cb).WithContext(ctx).Run(func() error { + return fn(ctx) + }) + }) } ``` +### Disabling for specific connections + +Use `WithoutExecutor()` to skip resilience for internal or loopback connections: + +```go +interceptors.DefaultClientInterceptor( + interceptors.WithoutExecutor(), +) +``` + +### Excluded errors + +Use `WithExcludedErrors` or `WithExcludedCodes` to prevent expected errors from tripping the circuit breaker: + +```go +interceptors.WithExcludedCodes(codes.NotFound, codes.InvalidArgument) +``` + +See the [interceptors examples](https://github.com/go-coldbrew/interceptors/tree/main/examples) for more patterns including circuit breaker + bulkhead composition. + +{: .warning } +**Legacy:** The previous `HystrixClientInterceptor` (wrapping `afex/hystrix-go`) is deprecated and will be removed in v1. Migrate to `SetDefaultExecutor` with [failsafe-go]. + ## Environment Configuration ColdBrew provides functions to configure the environment and release information used by monitoring tools. From e4ef1f2fb5ca42f334684b8dfd789e31292c7054 Mon Sep 17 00:00:00 2001 From: Ankur Shrivastava Date: Fri, 17 Apr 2026 15:26:39 +0800 Subject: [PATCH 2/5] docs: show method-filtering and per-call WithExecutor patterns --- integrations.md | 43 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 40 insertions(+), 3 deletions(-) diff --git a/integrations.md b/integrations.md index 2212eac..ef6c7bc 100644 --- a/integrations.md +++ b/integrations.md @@ -237,7 +237,7 @@ ColdBrew provides a pluggable executor hook for client-side resilience (circuit ### How it works -Call `interceptors.SetDefaultExecutor` during init to wrap all outbound gRPC calls with your resilience logic. The executor receives the gRPC method name, enabling per-method circuit breakers. +Call `interceptors.SetDefaultExecutor` during init to register your resilience logic. The executor receives the gRPC method name, so you can choose which methods get circuit breaking: ```go import ( @@ -253,7 +253,16 @@ func init() { WithSuccessThreshold(2). Build() + // Only apply circuit breaking to specific methods + protected := map[string]bool{ + "/payment.Service/Charge": true, + "/payment.Service/Refund": true, + } + interceptors.SetDefaultExecutor(func(ctx context.Context, method string, fn func(ctx context.Context) error) error { + if !protected[method] { + return fn(ctx) // passthrough for non-protected methods + } return failsafe.With[any](cb).WithContext(ctx).Run(func() error { return fn(ctx) }) @@ -301,12 +310,40 @@ interceptors.DefaultClientInterceptor( ) ``` +### Per-call executor + +`WithExecutor` can be passed directly to any gRPC call to use a specific executor for that call. This works even without calling `SetDefaultExecutor` — you don't need a global executor to use per-call executors. This is useful for per-service circuit breaker tuning. + +{: .note .note-info } +Per-call `WithExecutor` requires `ExecutorClientInterceptor` in the interceptor chain. This is included automatically when using `DefaultClientInterceptors`. If you build your own interceptor chain, make sure to include it. + +```go +// Create a sensitive circuit breaker for the payment service +paymentCB := circuitbreaker.NewBuilder[any](). + WithFailureThreshold(3). + WithDelay(10 * time.Second). + Build() + +paymentExec := func(ctx context.Context, method string, fn func(ctx context.Context) error) error { + return failsafe.With[any](paymentCB).WithContext(ctx).Run(func() error { + return fn(ctx) + }) +} + +// Pass it directly to the gRPC call +resp, err := paymentClient.Charge(ctx, req, + interceptors.WithExecutor(paymentExec), +) +``` + ### Excluded errors -Use `WithExcludedErrors` or `WithExcludedCodes` to prevent expected errors from tripping the circuit breaker: +Use `WithExcludedErrors` or `WithExcludedCodes` to prevent expected errors from tripping the circuit breaker. These can also be passed directly to gRPC calls: ```go -interceptors.WithExcludedCodes(codes.NotFound, codes.InvalidArgument) +resp, err := client.GetUser(ctx, req, + interceptors.WithExcludedCodes(codes.NotFound, codes.InvalidArgument), +) ``` See the [interceptors examples](https://github.com/go-coldbrew/interceptors/tree/main/examples) for more patterns including circuit breaker + bulkhead composition. From e2718eec08cba2e52513bea5956e7568d83b475e Mon Sep 17 00:00:00 2001 From: Ankur Shrivastava Date: Fri, 17 Apr 2026 15:29:03 +0800 Subject: [PATCH 3/5] docs: per-method circuit breakers with different limits --- integrations.md | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/integrations.md b/integrations.md index ef6c7bc..f7dd574 100644 --- a/integrations.md +++ b/integrations.md @@ -272,22 +272,39 @@ func init() { ### Per-method circuit breakers -For independent circuit breakers per gRPC method (so failures in one method don't trip another): +Each method can have its own circuit breaker with different limits — sensitive methods trip fast, tolerant methods allow more failures: ```go func init() { + type cbConfig struct { + failureThreshold uint + delay time.Duration + } + + configs := map[string]cbConfig{ + "/payment.Service/Charge": {failureThreshold: 3, delay: 10 * time.Second}, + "/payment.Service/Refund": {failureThreshold: 3, delay: 10 * time.Second}, + "/user.Service/GetUser": {failureThreshold: 10, delay: 5 * time.Second}, + "/feed.Service/GetFeed": {failureThreshold: 10, delay: 5 * time.Second}, + } + var ( mu sync.Mutex breakers = make(map[string]circuitbreaker.CircuitBreaker[any]) ) interceptors.SetDefaultExecutor(func(ctx context.Context, method string, fn func(ctx context.Context) error) error { - mu.Lock() - cb, ok := breakers[method] + cfg, ok := configs[method] if !ok { + return fn(ctx) // no circuit breaker for unconfigured methods + } + + mu.Lock() + cb, exists := breakers[method] + if !exists { cb = circuitbreaker.NewBuilder[any](). - WithFailureThreshold(5). - WithDelay(5 * time.Second). + WithFailureThreshold(cfg.failureThreshold). + WithDelay(cfg.delay). Build() breakers[method] = cb } From 6a0f1b9f2f0c3f3effbcb63f462a12020fae7c2a Mon Sep 17 00:00:00 2001 From: Ankur Shrivastava Date: Fri, 17 Apr 2026 17:17:44 +0800 Subject: [PATCH 4/5] =?UTF-8?q?fix:=20address=20review=20comments=20?= =?UTF-8?q?=E2=80=94=20consistent=20wording,=20remove=20unused=20refs,=20f?= =?UTF-8?q?ix=20Playwright=20test?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- FAQ.md | 2 +- Index.md | 2 +- howto/Metrics.md | 3 --- integrations.md | 2 -- tests/content.spec.ts | 4 ++-- 5 files changed, 4 insertions(+), 9 deletions(-) diff --git a/FAQ.md b/FAQ.md index de712d6..566af8c 100644 --- a/FAQ.md +++ b/FAQ.md @@ -121,7 +121,7 @@ See [Custom HTTP Routes](/howto/APIs/#custom-http-routes) for full examples incl ## Is hystrixprometheus still maintained? -**No.** The `hystrixprometheus` package depends on `afex/hystrix-go`, which is unmaintained and will be removed in v1. +**No.** The `hystrixprometheus` package depends on `afex/hystrix-go`, which is unmaintained and will be archived in v1. ColdBrew now provides a pluggable executor hook (`interceptors.SetDefaultExecutor`) for circuit breaking. Use [failsafe-go](https://github.com/failsafe-go/failsafe-go) as the recommended resilience library. See the [integrations page](/integrations/#circuit-breaker--resilience) for setup examples. diff --git a/Index.md b/Index.md index a4fd241..b970811 100644 --- a/Index.md +++ b/Index.md @@ -28,7 +28,7 @@ A Kubernetes-native Go microservice framework for building production-grade gRPC | **gRPC + REST Gateway** | Define your API once in protobuf — get gRPC, REST, and [Swagger docs](/architecture#self-documenting-apis) automatically via [grpc-gateway]. HTTP gateway supports JSON, `application/proto`, and `application/protobuf` [content types](/howto/APIs/#http-content-type) out of the box | | **Structured Logging** | Native [slog] with custom Handler — per-request context fields, trace ID propagation, and typed attrs for zero-boxing performance | | **Distributed Tracing** | [OpenTelemetry] and [New Relic] support with automatic span creation via gRPC stats handlers — traces can be sent to any OTLP-compatible backend including [Jaeger] | -| **Prometheus Metrics** | Built-in request latency, error rate metrics at `/metrics`, plus pluggable [resilience executor hook](/integrations/#circuit-breaker--resilience) for circuit breaking | +| **Prometheus Metrics** | Built-in request latency, error rate, and gRPC status code metrics at `/metrics` | | **Error Tracking** | Stack traces, gRPC status codes, and async notification to [Sentry], Rollbar, or Airbrake | | **Rate Limiting** | Per-pod token bucket rate limiter — disabled by default, pluggable via custom [`ratelimit.Limiter`](https://pkg.go.dev/github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/ratelimit#Limiter) interface for distributed or per-tenant rate limiting. Config: `RATE_LIMIT_PER_SECOND`. See [interceptors howto](/howto/interceptors#rate-limiting) | | **Auth Examples** | JWT and API key authentication interceptor examples in the [cookiecutter template][ColdBrew cookiecutter], built on [go-grpc-middleware auth](https://github.com/grpc-ecosystem/go-grpc-middleware/tree/main/interceptors/auth). See [auth howto](/howto/auth/) | diff --git a/howto/Metrics.md b/howto/Metrics.md index 7ae250b..1399d89 100644 --- a/howto/Metrics.md +++ b/howto/Metrics.md @@ -19,7 +19,6 @@ A collection of metrics are collected by default, including: * Golang runtime metrics (e.g. memory usage, goroutine count, etc.) * gRPC Client/Server metrics (e.g. request count, request duration, etc.) * HTTP request metrics (e.g. request count, request duration, etc.) -* [Hystrix-go] circuit breaker metrics (e.g. request count, request duration, etc.) powered by [Hystrix Prometheus] ## Application Metrics Package (Cookiecutter) @@ -157,7 +156,5 @@ ColdBrew's built-in `grpc_client_*` Prometheus metrics (request count, duration, --- [HTTP port]: https://pkg.go.dev/github.com/go-coldbrew/core/config#readme-type-config -[Hystrix Prometheus]: https://pkg.go.dev/github.com/go-coldbrew/hystrixprometheus -[Hystrix-go]: https://github.com/afex/hystrix-go [Prometheus Go client library]: https://github.com/prometheus/client_golang [ColdBrew cookiecutter]: /getting-started diff --git a/integrations.md b/integrations.md index f7dd574..6a6d6b5 100644 --- a/integrations.md +++ b/integrations.md @@ -435,7 +435,6 @@ To see all the ColdBrew packages, check out the [ColdBrew packages] page. [Sentry]: https://sentry.io/welcome/ [Opentelemetry]: https://opentelemetry.io/ [Jaeger]: https://www.jaegertracing.io/ -[Hystrix-Go]: https://pkg.go.dev/github.com/afex/hystrix-go/hystrix [Go-grpc-middleware]: https://github.com/grpc-ecosystem/go-grpc-middleware/v2 [Core]: https://github.com/go-coldbrew/core/tree/main#readme [ColdBrew packages]: /packages @@ -452,7 +451,6 @@ To see all the ColdBrew packages, check out the [ColdBrew packages] page. [OTLPConfig]: https://pkg.go.dev/github.com/go-coldbrew/core#OTLPConfig [SetupOpenTelemetry]: https://pkg.go.dev/github.com/go-coldbrew/core#SetupOpenTelemetry [SetupLogger]: https://pkg.go.dev/github.com/go-coldbrew/core#SetupLogger -[SetupHystrixPrometheus]: https://pkg.go.dev/github.com/go-coldbrew/core#SetupHystrixPrometheus [failsafe-go]: https://github.com/failsafe-go/failsafe-go [SetupEnvironment]: https://pkg.go.dev/github.com/go-coldbrew/core#SetupEnvironment [SetupReleaseName]: https://pkg.go.dev/github.com/go-coldbrew/core#SetupReleaseName diff --git a/tests/content.spec.ts b/tests/content.spec.ts index 71d32e1..a409f98 100644 --- a/tests/content.spec.ts +++ b/tests/content.spec.ts @@ -91,10 +91,10 @@ test.describe("Callouts", () => { expect(await callout.count()).toBeGreaterThan(0); }); - test("metrics page has warning about hystrix", async ({ page }) => { + test("metrics page has legacy warning about hystrix", async ({ page }) => { await page.goto("/howto/Metrics/"); const pageText = await page.locator("main, .main-content").first().textContent(); - expect(pageText).toContain("unmaintained"); + expect(pageText).toContain("deprecated"); }); }); From 2337c9a75e70d95f67c6f14db5205e8e1c112974 Mon Sep 17 00:00:00 2001 From: Ankur Shrivastava Date: Fri, 17 Apr 2026 18:15:47 +0800 Subject: [PATCH 5/5] fix: more specific Playwright assertion, simplify anchor links --- FAQ.md | 2 +- tests/content.spec.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/FAQ.md b/FAQ.md index 566af8c..a5198fe 100644 --- a/FAQ.md +++ b/FAQ.md @@ -123,7 +123,7 @@ See [Custom HTTP Routes](/howto/APIs/#custom-http-routes) for full examples incl **No.** The `hystrixprometheus` package depends on `afex/hystrix-go`, which is unmaintained and will be archived in v1. -ColdBrew now provides a pluggable executor hook (`interceptors.SetDefaultExecutor`) for circuit breaking. Use [failsafe-go](https://github.com/failsafe-go/failsafe-go) as the recommended resilience library. See the [integrations page](/integrations/#circuit-breaker--resilience) for setup examples. +ColdBrew now provides a pluggable executor hook (`interceptors.SetDefaultExecutor`) for circuit breaking. Use [failsafe-go](https://github.com/failsafe-go/failsafe-go) as the recommended resilience library. See the [integrations page](/integrations/) for setup examples. ## How do I do cross-package development? diff --git a/tests/content.spec.ts b/tests/content.spec.ts index a409f98..6ab0398 100644 --- a/tests/content.spec.ts +++ b/tests/content.spec.ts @@ -94,7 +94,7 @@ test.describe("Callouts", () => { test("metrics page has legacy warning about hystrix", async ({ page }) => { await page.goto("/howto/Metrics/"); const pageText = await page.locator("main, .main-content").first().textContent(); - expect(pageText).toContain("deprecated"); + expect(pageText).toContain("SetupHystrixPrometheus"); }); });