From 9c0a983cc2c2fe5d79b2fca564a01124b5b4d371 Mon Sep 17 00:00:00 2001 From: William Law Date: Mon, 29 Sep 2025 13:58:52 -0400 Subject: [PATCH 1/8] spike forwarding --- proxyd/backend.go | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/proxyd/backend.go b/proxyd/backend.go index b1d035b4..469495a2 100644 --- a/proxyd/backend.go +++ b/proxyd/backend.go @@ -311,6 +311,7 @@ type Backend struct { maxWSConns int outOfServiceInterval time.Duration stripTrailingXFF bool + ingressRPC string proxydIP string skipIsSyncingCheck bool @@ -474,6 +475,12 @@ func WithConsensusReceiptTarget(receiptsTarget string) BackendOpt { } } +func WithIngressRPC(ingressRPC string) BackendOpt { + return func(b *Backend) { + b.ingressRPC = ingressRPC + } +} + func WithIntermittentNetworkErrorSlidingWindow(sw *sw.AvgSlidingWindow) BackendOpt { return func(b *Backend) { b.intermittentErrorsSlidingWindow = sw @@ -820,6 +827,20 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool httpReq.Header.Set(name, value) } + if b.ingressRPC != "" { + // Send async copy to ingress service, don't wait for error handling + go func() { + ingressReq, _ := http.NewRequestWithContext(ctx, "POST", b.ingressRPC, bytes.NewReader(body)) + ingressReq.Header.Set("content-type", "application/json") + ingressReq.Header.Set("X-Forwarded-For", xForwardedFor) + for name, value := range b.headers { + ingressReq.Header.Set(name, value) + } + httpRes, _ := http.DefaultClient.Do(ingressReq) + httpRes.Body.Close() + }() + } + start := time.Now() httpRes, err := b.client.DoLimited(httpReq) if httpRes != nil && httpRes.Body != nil { From 20738b6bf13185d72dcb4804ec72ec77f8e06eff Mon Sep 17 00:00:00 2001 From: William Law Date: Mon, 29 Sep 2025 14:12:13 -0400 Subject: [PATCH 2/8] add unit test --- proxyd/backend.go | 2 +- proxyd/backend_test.go | 70 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 1 deletion(-) diff --git a/proxyd/backend.go b/proxyd/backend.go index 469495a2..2335fb02 100644 --- a/proxyd/backend.go +++ b/proxyd/backend.go @@ -839,7 +839,7 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool httpRes, _ := http.DefaultClient.Do(ingressReq) httpRes.Body.Close() }() - } + } start := time.Now() httpRes, err := b.client.DoLimited(httpReq) diff --git a/proxyd/backend_test.go b/proxyd/backend_test.go index e8ed9d71..479cb797 100644 --- a/proxyd/backend_test.go +++ b/proxyd/backend_test.go @@ -2,6 +2,7 @@ package proxyd import ( "context" + "io" "net/http" "net/http/httptest" "strings" @@ -211,6 +212,75 @@ func TestAllowedStatusCodes(t *testing.T) { require.Equal(t, http.StatusServiceUnavailable, res[0].Error.HTTPErrorCode) } +func TestIngressForwarding(t *testing.T) { + backendRequests := make(chan []byte, 10) + ingressRequests := make(chan []byte, 10) + + // Mock backend server + backendServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, _ := io.ReadAll(r.Body) + backendRequests <- body + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte(`{"jsonrpc":"2.0","result":"0x1234","id":1}`)) + })) + defer backendServer.Close() + + // Mock ingress server + ingressServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, _ := io.ReadAll(r.Body) + ingressRequests <- body + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte(`{"jsonrpc":"2.0","result":"ok","id":1}`)) + })) + defer ingressServer.Close() + + // Create backend with ingress RPC configured + backend := NewBackend( + "test-backend", + backendServer.URL, + "", + semaphore.NewWeighted(10), + WithIngressRPC(ingressServer.URL), + ) + + // Create a test RPC request + rpcReq := &RPCReq{ + JSONRPC: "2.0", + Method: "eth_blockNumber", + Params: []byte(`[]`), + ID: []byte(`1`), + } + + // Forward the request + ctx := context.Background() + res, err := backend.Forward(ctx, []*RPCReq{rpcReq}, false) + + // Verify the backend request was successful + require.NoError(t, err) + require.Len(t, res, 1) + require.False(t, res[0].IsError()) + + // Verify both backend and ingress received the request + select { + case backendBody := <-backendRequests: + require.Contains(t, string(backendBody), "eth_blockNumber") + require.Contains(t, string(backendBody), `"id":1`) + case <-time.After(100 * time.Millisecond): + t.Fatal("Backend did not receive request") + } + + // Give a bit more time for the async ingress request to complete + select { + case ingressBody := <-ingressRequests: + require.Contains(t, string(ingressBody), "eth_blockNumber") + require.Contains(t, string(ingressBody), `"id":1`) + case <-time.After(500 * time.Millisecond): + t.Fatal("Ingress did not receive request") + } +} + func getHttpResponseCodeCount(statusCode string) float64 { metricFamilies, err := prometheus.DefaultGatherer.Gather() if err != nil { From c9c5ac4f40fec74d10b4833ae753bb5418c1669c Mon Sep 17 00:00:00 2001 From: William Law Date: Tue, 30 Sep 2025 11:03:16 -0400 Subject: [PATCH 3/8] add req count and res time metric --- proxyd/backend.go | 5 +++++ proxyd/metrics.go | 25 +++++++++++++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/proxyd/backend.go b/proxyd/backend.go index 2335fb02..4ca4ba4c 100644 --- a/proxyd/backend.go +++ b/proxyd/backend.go @@ -830,14 +830,19 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool if b.ingressRPC != "" { // Send async copy to ingress service, don't wait for error handling go func() { + RecordIngressRequest(b.Name) + ingressReq, _ := http.NewRequestWithContext(ctx, "POST", b.ingressRPC, bytes.NewReader(body)) ingressReq.Header.Set("content-type", "application/json") ingressReq.Header.Set("X-Forwarded-For", xForwardedFor) for name, value := range b.headers { ingressReq.Header.Set(name, value) } + + ingressStart := time.Now() httpRes, _ := http.DefaultClient.Do(ingressReq) httpRes.Body.Close() + RecordIngressRequestDuration(b.Name, time.Since(ingressStart)) }() } diff --git a/proxyd/metrics.go b/proxyd/metrics.go index 0400c574..3563a8b2 100644 --- a/proxyd/metrics.go +++ b/proxyd/metrics.go @@ -480,6 +480,14 @@ var ( "backend_name", }) + ingressRequestsTotal = promauto.NewCounterVec(prometheus.CounterOpts{ + Namespace: MetricsNamespace, + Name: "tips_ingress_requests_total", + Help: "Count of total requests forwarded to TIPS ingress service.", + }, []string{ + "backend_name", + }) + backendProbeChecksTotal = promauto.NewCounterVec(prometheus.CounterOpts{ Namespace: MetricsNamespace, Name: "backend_probe_checks_total", @@ -497,6 +505,15 @@ var ( }, []string{ "backend_name", }) + + ingressRequestDurationSumm = promauto.NewSummaryVec(prometheus.SummaryOpts{ + Namespace: MetricsNamespace, + Name: "tips_ingress_request_duration_seconds", + Help: "Summary of TIPS ingress request response times broken down by backend.", + Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.005, 0.99: 0.001}, + }, []string{ + "backend_name", + }) ) func RecordRedisError(source string) { @@ -686,6 +703,14 @@ func RecordBackendProbeDuration(backendName string, duration time.Duration) { backendProbeDurationHist.WithLabelValues(backendName).Observe(duration.Seconds()) } +func RecordIngressRequest(backendName string) { + ingressRequestsTotal.WithLabelValues(backendName).Inc() +} + +func RecordIngressRequestDuration(backendName string, duration time.Duration) { + ingressRequestDurationSumm.WithLabelValues(backendName).Observe(duration.Seconds()) +} + func boolToFloat64(b bool) float64 { if b { return 1 From b92d0583c00e430618494bed9c324c34ce627a93 Mon Sep 17 00:00:00 2001 From: Danyal Prout Date: Thu, 9 Oct 2025 11:13:42 -0500 Subject: [PATCH 4/8] chore: support address rate limiting for send raw transaction sync --- proxyd/server.go | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/proxyd/server.go b/proxyd/server.go index 9c951381..af665def 100644 --- a/proxyd/server.go +++ b/proxyd/server.go @@ -646,7 +646,7 @@ func (s *Server) handleBatchRPC(ctx context.Context, reqs []json.RawMessage, isL // Apply a sender-based rate limit if it is enabled. Note that sender-based rate // limits apply regardless of origin or user-agent. As such, they don't use the // isLimited method. - if parsedReq.Method == "eth_sendRawTransaction" || parsedReq.Method == "eth_sendRawTransactionConditional" { + if parsedReq.Method == "eth_sendRawTransaction" || parsedReq.Method == "eth_sendRawTransactionConditional" || parsedReq.Method == "eth_sendRawTransactionSync" { tx, err := s.convertSendReqToSendTx(ctx, parsedReq) if err != nil { RecordRPCError(ctx, BackendProxyd, parsedReq.Method, err) @@ -907,15 +907,19 @@ func (s *Server) convertSendReqToSendTx(ctx context.Context, req *RPCReq) (*type log.Debug("raw transaction conditional request has invalid number of params", "req_id", GetReqID(ctx)) // The error below is identical to the one Geth responds with. return nil, ErrInvalidParams("missing value for required argument 0 or 1") + } else if req.Method == "eth_sendRawTransactionSync" && (len(params) == 0 || len(params) > 2) { + log.Debug("raw transaction sync request has invalid number of params", "req_id", GetReqID(ctx)) + // The error below is identical to the one Geth responds with. + return nil, ErrInvalidParams("missing value for required argument 0") } - address, ok := params[0].(string) + signedTransaction, ok := params[0].(string) if !ok { return nil, ErrParseErr } var data hexutil.Bytes - if err := data.UnmarshalText([]byte(address)); err != nil { + if err := data.UnmarshalText([]byte(signedTransaction)); err != nil { log.Debug("error decoding raw tx data", "err", err, "req_id", GetReqID(ctx)) // Geth returns the raw error from UnmarshalText. return nil, ErrInvalidParams(err.Error()) From 629c288a47e8d075f9f552197b9c1ce621b31e9a Mon Sep 17 00:00:00 2001 From: Danyal Prout Date: Wed, 8 Oct 2025 15:14:13 -0500 Subject: [PATCH 5/8] fix: setup routing from config --- proxyd/backend.go | 11 ++++++++--- proxyd/config.go | 2 ++ proxyd/proxyd.go | 4 ++++ 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/proxyd/backend.go b/proxyd/backend.go index 4ca4ba4c..2608deee 100644 --- a/proxyd/backend.go +++ b/proxyd/backend.go @@ -840,9 +840,14 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool } ingressStart := time.Now() - httpRes, _ := http.DefaultClient.Do(ingressReq) - httpRes.Body.Close() - RecordIngressRequestDuration(b.Name, time.Since(ingressStart)) + httpRes, err := http.DefaultClient.Do(ingressReq) + if err != nil { + log.Warn("failed to proxy to ingress rpc", err) + } else { + defer httpRes.Body.Close() + RecordIngressRequestDuration(b.Name, time.Since(ingressStart)) + } + }() } diff --git a/proxyd/config.go b/proxyd/config.go index 6d09d9e1..94eb05ef 100644 --- a/proxyd/config.go +++ b/proxyd/config.go @@ -137,6 +137,8 @@ type BackendConfig struct { ConsensusForcedCandidate bool `toml:"consensus_forced_candidate"` ConsensusReceiptsTarget string `toml:"consensus_receipts_target"` AllowedStatusCodes []int `toml:"allowed_status_codes"` + + IngressRPC string `toml:"ingress_rpc"` } type BackendsConfig map[string]*BackendConfig diff --git a/proxyd/proxyd.go b/proxyd/proxyd.go index b3d23417..c471afac 100644 --- a/proxyd/proxyd.go +++ b/proxyd/proxyd.go @@ -184,6 +184,10 @@ func Start(config *Config) (*Server, func(), error) { if cfg.ProbeURL != "" { opts = append(opts, WithProbe(cfg.ProbeURL, cfg.ProbeFailureThreshold, cfg.ProbeSuccessThreshold, cfg.ProbePeriodSeconds, cfg.ProbeTimeoutSeconds)) } + + if cfg.IngressRPC != "" { + opts = append(opts, WithIngressRPC(cfg.IngressRPC)) + } headers := map[string]string{} for headerName, headerValue := range cfg.Headers { From 9fdb152b4554cc74172a3d2865de2b24dcbe038b Mon Sep 17 00:00:00 2001 From: Danyal Prout Date: Wed, 8 Oct 2025 22:51:03 -0500 Subject: [PATCH 6/8] migrate ingress rpc to only send raw txn --- proxyd/backend.go | 30 ------------------------------ proxyd/config.go | 1 + proxyd/metrics.go | 16 ++++++---------- proxyd/proxyd.go | 1 + proxyd/server.go | 36 ++++++++++++++++++++++++++++++++++++ 5 files changed, 44 insertions(+), 40 deletions(-) diff --git a/proxyd/backend.go b/proxyd/backend.go index 2608deee..7e6b8a75 100644 --- a/proxyd/backend.go +++ b/proxyd/backend.go @@ -475,12 +475,6 @@ func WithConsensusReceiptTarget(receiptsTarget string) BackendOpt { } } -func WithIngressRPC(ingressRPC string) BackendOpt { - return func(b *Backend) { - b.ingressRPC = ingressRPC - } -} - func WithIntermittentNetworkErrorSlidingWindow(sw *sw.AvgSlidingWindow) BackendOpt { return func(b *Backend) { b.intermittentErrorsSlidingWindow = sw @@ -827,30 +821,6 @@ func (b *Backend) doForward(ctx context.Context, rpcReqs []*RPCReq, isBatch bool httpReq.Header.Set(name, value) } - if b.ingressRPC != "" { - // Send async copy to ingress service, don't wait for error handling - go func() { - RecordIngressRequest(b.Name) - - ingressReq, _ := http.NewRequestWithContext(ctx, "POST", b.ingressRPC, bytes.NewReader(body)) - ingressReq.Header.Set("content-type", "application/json") - ingressReq.Header.Set("X-Forwarded-For", xForwardedFor) - for name, value := range b.headers { - ingressReq.Header.Set(name, value) - } - - ingressStart := time.Now() - httpRes, err := http.DefaultClient.Do(ingressReq) - if err != nil { - log.Warn("failed to proxy to ingress rpc", err) - } else { - defer httpRes.Body.Close() - RecordIngressRequestDuration(b.Name, time.Since(ingressStart)) - } - - }() - } - start := time.Now() httpRes, err := b.client.DoLimited(httpReq) if httpRes != nil && httpRes.Body != nil { diff --git a/proxyd/config.go b/proxyd/config.go index 94eb05ef..a8502959 100644 --- a/proxyd/config.go +++ b/proxyd/config.go @@ -251,6 +251,7 @@ type Config struct { SenderRateLimit SenderRateLimitConfig `toml:"sender_rate_limit"` InteropValidationConfig InteropValidationConfig `toml:"interop_validation"` TxValidationMiddlewareConfig TxValidationMiddlewareConfig `toml:"tx_validation_middleware"` + IngressRPC string `toml:"ingress_rpc"` } type InteropValidationConfig struct { diff --git a/proxyd/metrics.go b/proxyd/metrics.go index 3563a8b2..9a029b3d 100644 --- a/proxyd/metrics.go +++ b/proxyd/metrics.go @@ -480,12 +480,10 @@ var ( "backend_name", }) - ingressRequestsTotal = promauto.NewCounterVec(prometheus.CounterOpts{ + ingressRequestsTotal = promauto.NewCounter(prometheus.CounterOpts{ Namespace: MetricsNamespace, Name: "tips_ingress_requests_total", Help: "Count of total requests forwarded to TIPS ingress service.", - }, []string{ - "backend_name", }) backendProbeChecksTotal = promauto.NewCounterVec(prometheus.CounterOpts{ @@ -506,13 +504,11 @@ var ( "backend_name", }) - ingressRequestDurationSumm = promauto.NewSummaryVec(prometheus.SummaryOpts{ + ingressRequestDurationSum = promauto.NewSummary(prometheus.SummaryOpts{ Namespace: MetricsNamespace, Name: "tips_ingress_request_duration_seconds", Help: "Summary of TIPS ingress request response times broken down by backend.", Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.005, 0.99: 0.001}, - }, []string{ - "backend_name", }) ) @@ -703,12 +699,12 @@ func RecordBackendProbeDuration(backendName string, duration time.Duration) { backendProbeDurationHist.WithLabelValues(backendName).Observe(duration.Seconds()) } -func RecordIngressRequest(backendName string) { - ingressRequestsTotal.WithLabelValues(backendName).Inc() +func RecordIngressRequest() { + ingressRequestsTotal.Inc() } -func RecordIngressRequestDuration(backendName string, duration time.Duration) { - ingressRequestDurationSumm.WithLabelValues(backendName).Observe(duration.Seconds()) +func RecordIngressRequestDuration(duration time.Duration) { + ingressRequestDurationSum.Observe(duration.Seconds()) } func boolToFloat64(b bool) float64 { diff --git a/proxyd/proxyd.go b/proxyd/proxyd.go index c471afac..83d5bf2e 100644 --- a/proxyd/proxyd.go +++ b/proxyd/proxyd.go @@ -512,6 +512,7 @@ func Start(config *Config) (*Server, func(), error) { apiKeys, config.TxValidationMiddlewareConfig, time.Duration(config.Server.GracefulShutdownSeconds)*time.Second, + config.IngressRPC, ) if err != nil { return nil, nil, fmt.Errorf("error creating server: %w", err) diff --git a/proxyd/server.go b/proxyd/server.go index af665def..7356e1e2 100644 --- a/proxyd/server.go +++ b/proxyd/server.go @@ -1,6 +1,7 @@ package proxyd import ( + "bytes" "context" "crypto/rand" "crypto/subtle" @@ -90,6 +91,8 @@ type Server struct { interopValidatingConfig InteropValidationConfig interopStrategy InteropStrategy publicAccess bool + ingressRpc string + ingressRpcClient *http.Client enableTxHashLogging bool enableTxValidation bool @@ -131,6 +134,7 @@ func NewServer( limExemptKeys []string, txValidationConfig TxValidationMiddlewareConfig, gracefulShutdownDuration time.Duration, + ingressRpc string, ) (*Server, error) { if cache == nil { cache = &NoopRPCCache{} @@ -259,6 +263,13 @@ func NewServer( txValidationClient: txValidationClient, txValidationFailOpen: txValidationFailOpen, gracefulShutdownDuration: gracefulShutdownDuration, + ingressRpc: ingressRpc, + ingressRpcClient: &http.Client{ + Timeout: defaultRPCTimeout, + CheckRedirect: func(req *http.Request, via []*http.Request) error { + return http.ErrUseLastResponse + }, + }, }, nil } @@ -663,6 +674,31 @@ func (s *Server) handleBatchRPC(ctx context.Context, reqs []json.RawMessage, isL responses[i] = NewRPCErrorRes(parsedReq.ID, err) continue } + + // Send async copy to ingress service, don't wait for error handling + if s.ingressRpc != "" { + body, err := json.Marshal(parsedReq) + if err != nil { + log.Error("unable to marshal JSON RPC request", "source", "rpc", "err", err) + } else { + go func() { + RecordIngressRequest() + + ingressStart := time.Now() + req, err := http.NewRequest(http.MethodPost, s.ingressRpc, bytes.NewBuffer(body)) + req.Header.Set("Content-Type", "application/json") + + resp, err := s.ingressRpcClient.Do(req) + if err != nil { + log.Warn("failed to proxy to ingress rpc", "err", err) + return + } + + defer resp.Body.Close() + RecordIngressRequestDuration(time.Since(ingressStart)) + }() + } + } } // Apply transaction validation middleware if enabled and method is configured. From 06be5dd1a56d8e939a11c7c97828b17a90186930 Mon Sep 17 00:00:00 2001 From: William Law Date: Thu, 5 Feb 2026 10:39:34 -0500 Subject: [PATCH 7/8] fmt --- proxyd/config.go | 2 +- proxyd/proxyd.go | 2 +- proxyd/server.go | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/proxyd/config.go b/proxyd/config.go index a8502959..f0aee345 100644 --- a/proxyd/config.go +++ b/proxyd/config.go @@ -251,7 +251,7 @@ type Config struct { SenderRateLimit SenderRateLimitConfig `toml:"sender_rate_limit"` InteropValidationConfig InteropValidationConfig `toml:"interop_validation"` TxValidationMiddlewareConfig TxValidationMiddlewareConfig `toml:"tx_validation_middleware"` - IngressRPC string `toml:"ingress_rpc"` + IngressRPC string `toml:"ingress_rpc"` } type InteropValidationConfig struct { diff --git a/proxyd/proxyd.go b/proxyd/proxyd.go index 83d5bf2e..31ea4fe4 100644 --- a/proxyd/proxyd.go +++ b/proxyd/proxyd.go @@ -184,7 +184,7 @@ func Start(config *Config) (*Server, func(), error) { if cfg.ProbeURL != "" { opts = append(opts, WithProbe(cfg.ProbeURL, cfg.ProbeFailureThreshold, cfg.ProbeSuccessThreshold, cfg.ProbePeriodSeconds, cfg.ProbeTimeoutSeconds)) } - + if cfg.IngressRPC != "" { opts = append(opts, WithIngressRPC(cfg.IngressRPC)) } diff --git a/proxyd/server.go b/proxyd/server.go index 7356e1e2..4217aae9 100644 --- a/proxyd/server.go +++ b/proxyd/server.go @@ -263,13 +263,13 @@ func NewServer( txValidationClient: txValidationClient, txValidationFailOpen: txValidationFailOpen, gracefulShutdownDuration: gracefulShutdownDuration, - ingressRpc: ingressRpc, + ingressRpc: ingressRpc, ingressRpcClient: &http.Client{ Timeout: defaultRPCTimeout, CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse }, - }, + }, }, nil } @@ -698,7 +698,7 @@ func (s *Server) handleBatchRPC(ctx context.Context, reqs []json.RawMessage, isL RecordIngressRequestDuration(time.Since(ingressStart)) }() } - } + } } // Apply transaction validation middleware if enabled and method is configured. From 302365b9aeb30b56e5143295b37c7151f1479157 Mon Sep 17 00:00:00 2001 From: William Law Date: Thu, 5 Feb 2026 10:46:01 -0500 Subject: [PATCH 8/8] make similar to current release branch --- proxyd/config.go | 2 -- proxyd/proxyd.go | 4 ---- 2 files changed, 6 deletions(-) diff --git a/proxyd/config.go b/proxyd/config.go index f0aee345..7b07dc24 100644 --- a/proxyd/config.go +++ b/proxyd/config.go @@ -137,8 +137,6 @@ type BackendConfig struct { ConsensusForcedCandidate bool `toml:"consensus_forced_candidate"` ConsensusReceiptsTarget string `toml:"consensus_receipts_target"` AllowedStatusCodes []int `toml:"allowed_status_codes"` - - IngressRPC string `toml:"ingress_rpc"` } type BackendsConfig map[string]*BackendConfig diff --git a/proxyd/proxyd.go b/proxyd/proxyd.go index 31ea4fe4..944d242e 100644 --- a/proxyd/proxyd.go +++ b/proxyd/proxyd.go @@ -185,10 +185,6 @@ func Start(config *Config) (*Server, func(), error) { opts = append(opts, WithProbe(cfg.ProbeURL, cfg.ProbeFailureThreshold, cfg.ProbeSuccessThreshold, cfg.ProbePeriodSeconds, cfg.ProbeTimeoutSeconds)) } - if cfg.IngressRPC != "" { - opts = append(opts, WithIngressRPC(cfg.IngressRPC)) - } - headers := map[string]string{} for headerName, headerValue := range cfg.Headers { headerValue, err := ReadFromEnvOrConfig(headerValue)