SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
feat(apiserver): add tls support to http server (#12830)
Pandey1419e03ec102
diff --git a/.claude/rules/go-test.md b/.claude/rules/go-test.mdnew file mode 100644index 0000000000..80fd64b457--- /dev/null+++ b/.claude/rules/go-test.md@@ -0,0 +1,12 @@+---+paths:+ - "**/*_test.go"+---++# Go tests++- **testify + table-driven.** Use `assert` / `require`; prefer table-driven cases. Tests live next to the source file.+- **`require` vs `assert`.** `require` for anything the rest of the test cannot proceed without — setup, `require.NoError(t, err)`, nil/length checks before indexing or dereferencing. `assert` for the actual expectations, so one failed check still reports the rest.+- **Mock with mockery.** When an interface needs mocking, list it in `.mockery.yml` and run `mockery`; never hand-write mocks. Generated mocks live in the source package's `<pkg>test` sibling (e.g. `resourcestest.NewMockAdapter(t)`).+- **Table format.** Declare cases as `testCases := []struct{ name string; ... }` and iterate with `for _, testCase := range testCases { t.Run(testCase.name, ...) }` — the variables are named `testCases` / `testCase`. Case names are PascalCase segments joined by `_`, one segment per aspect (scenario, condition, expectation): `TimestampNotNullNoDefault`, `DropPrimaryKeyConstraint_AlterColumnNullable`, `ForeignKeyConstraint_DoesNotExist_SCreateAndDropConstraintTrue`.+- **No hoisted test constants.** When goconst flags a repeated literal in a test, vary the fixture strings across cases instead of hoisting a constant — never introduce a shared const for test data.diff --git a/conf/example.yaml b/conf/example.yamlindex 34a6fc3e28..f0d1f0314a 100644--- a/conf/example.yaml+++ b/conf/example.yaml@@ -144,6 +144,12 @@ apiserver:read_timeout: 60s# Keep at 0; any value cuts off streaming endpoints (livetail, SSE, export_raw_data).write_timeout: 0+ # tls:+ # enabled: true+ # cert_file: /path/to/server.crt+ # key_file: /path/to/server.key+ # # Minimum TLS version: "1.2" or "1.3". Defaults to "1.2".+ # min_version: "1.2"timeout:# Default request timeout.default: 60sdiff --git a/docs/contributing/go/service.md b/docs/contributing/go/service.mdindex 736e4d62fd..8b6e9d1560 100644--- a/docs/contributing/go/service.md+++ b/docs/contributing/go/service.md@@ -191,7 +191,7 @@ A standalone service only has the `factory.Service` lifecycle i.e it does not se// ... dependencies ...) user.Service {return &service{- settings: factory.NewScopedProviderSettings(providerSettings, "go.signoz.io/pkg/modules/user"),+ settings: factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/modules/user"),// ... dependencies ...stopC: make(chan struct{}),}diff --git a/pkg/apiserver/config.go b/pkg/apiserver/config.goindex 909830a04b..83d8be220f 100644--- a/pkg/apiserver/config.go+++ b/pkg/apiserver/config.go@@ -59,6 +59,10 @@ func newConfig() factory.Config {}func (c Config) Validate() error {+ if err := c.Config.Validate(); err != nil {+ return err+ }+if c.Address == "" {return errors.NewInvalidInputf(errors.CodeInvalidInput, "apiserver.address is required")}diff --git a/pkg/apiserver/config_test.go b/pkg/apiserver/config_test.goindex 4e911cdd25..2cc7a05fac 100644--- a/pkg/apiserver/config_test.go+++ b/pkg/apiserver/config_test.go@@ -16,6 +16,10 @@ import (func TestNewWithEnvProvider(t *testing.T) {t.Setenv("SIGNOZ_APISERVER_ADDRESS", "0.0.0.0:9090")t.Setenv("SIGNOZ_APISERVER_READ__TIMEOUT", "80s")+ t.Setenv("SIGNOZ_APISERVER_TLS_ENABLED", "true")+ t.Setenv("SIGNOZ_APISERVER_TLS_CERT__FILE", "/etc/signoz/server.crt")+ t.Setenv("SIGNOZ_APISERVER_TLS_KEY__FILE", "/etc/signoz/server.key")+ t.Setenv("SIGNOZ_APISERVER_TLS_MIN__VERSION", "1.3")t.Setenv("SIGNOZ_APISERVER_TIMEOUT_DEFAULT", "70s")t.Setenv("SIGNOZ_APISERVER_TIMEOUT_MAX", "700s")t.Setenv("SIGNOZ_APISERVER_TIMEOUT_EXCLUDED__ROUTES", "/excluded1,/excluded2")@@ -44,6 +48,12 @@ func TestNewWithEnvProvider(t *testing.T) {Config: httpserver.Config{Address: "0.0.0.0:9090",ReadTimeout: 80 * time.Second,+ TLS: httpserver.TLS{+ Enabled: true,+ CertFile: "/etc/signoz/server.crt",+ KeyFile: "/etc/signoz/server.key",+ MinVersion: "1.3",+ },},Timeout: Timeout{Default: 70 * time.Second,diff --git a/pkg/http/server/config.go b/pkg/http/server/config.goindex 6b50817bd1..de1ed10f68 100644--- a/pkg/http/server/config.go+++ b/pkg/http/server/config.go@@ -1,10 +1,19 @@package server-import "time"+import (+ "crypto/tls"+ "time"++ "github.com/SigNoz/signoz/pkg/errors"+)++var tlsVersions = map[string]uint16{+ "1.2": tls.VersionTLS12,+ "1.3": tls.VersionTLS13,+}-// Config holds the configuration for http.type Config struct {- //Address specifies the TCP address for the server to listen on, in the form "host:port".+ // Address specifies the TCP address for the server to listen on, in the form "host:port".// If empty, ":http" (port 80) is used. The service names are defined in RFC 6335 and assigned by IANA.// See net.Dial for details of the address format.Address string `mapstructure:"address"`@@ -15,4 +24,66 @@ type Config struct {// WriteTimeout bounds writing the response. Zero means no timeout, required for// streaming endpoints that hold the connection open.WriteTimeout time.Duration `mapstructure:"write_timeout"`++ TLS TLS `mapstructure:"tls"`+}++type TLS struct {+ Enabled bool `mapstructure:"enabled"`++ // The full path to the certificate file.+ CertFile string `mapstructure:"cert_file"`++ // The full path to the key file.+ KeyFile string `mapstructure:"key_file"`++ // MinVersion is the minimum acceptable TLS version, "1.2" or "1.3". Empty uses the Go default.+ MinVersion string `mapstructure:"min_version"`+}++func (c Config) Validate() error {+ if !c.TLS.Enabled {+ return nil+ }++ if c.TLS.CertFile == "" || c.TLS.KeyFile == "" {+ return errors.NewInvalidInputf(errors.CodeInvalidInput, "tls::cert_file and tls::key_file are required when tls is enabled")+ }++ _, err := tlsVersion(c.TLS.MinVersion)+ if err != nil {+ return err+ }++ return nil+}++func (tlsConfig TLS) Config() (*tls.Config, error) {+ cert, err := tls.LoadX509KeyPair(tlsConfig.CertFile, tlsConfig.KeyFile)+ if err != nil {+ return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "cannot load tls::cert_file and tls::key_file: %v", err)+ }++ minVersion, err := tlsVersion(tlsConfig.MinVersion)+ if err != nil {+ return nil, err+ }++ return &tls.Config{+ Certificates: []tls.Certificate{cert},+ MinVersion: minVersion,+ }, nil+}++func tlsVersion(name string) (uint16, error) {+ if name == "" {+ return 0, nil+ }++ version, ok := tlsVersions[name]+ if !ok {+ return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid tls version %q, must be \"1.2\" or \"1.3\"", name)+ }++ return version, nil}diff --git a/pkg/http/server/server.go b/pkg/http/server/server.goindex b13e35e83c..94209c8b20 100644--- a/pkg/http/server/server.go+++ b/pkg/http/server/server.go@@ -28,6 +28,10 @@ func New(logger *slog.Logger, cfg Config, handler http.Handler) (*Server, error)return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "cannot build http server, logger is required")}+ if err := cfg.Validate(); err != nil {+ return nil, err+ }+srv := &http.Server{Addr: cfg.Address,Handler: handler,@@ -36,9 +40,18 @@ func New(logger *slog.Logger, cfg Config, handler http.Handler) (*Server, error)MaxHeaderBytes: 1 << 20,}+ if cfg.TLS.Enabled {+ tlsConfig, err := cfg.TLS.Config()+ if err != nil {+ return nil, err+ }++ srv.TLSConfig = tlsConfig+ }+return &Server{srv: srv,- logger: logger.With(slog.String("pkg", "go.signoz.io/pkg/http/server")),+ logger: logger.With(slog.String("pkg", "github.com/SigNoz/signoz/pkg/http/server")),handler: handler,cfg: cfg,}, nil@@ -46,11 +59,18 @@ func New(logger *slog.Logger, cfg Config, handler http.Handler) (*Server, error)func (server *Server) Start(ctx context.Context) error {server.logger.InfoContext(ctx, "starting http server", slog.String("address", server.srv.Addr))- if err := server.srv.ListenAndServe(); err != nil {- if err != http.ErrServerClosed {- server.logger.ErrorContext(ctx, "failed to start server", errors.Attr(err))- return err- }++ var err error+ if server.cfg.TLS.Enabled {+ // The certificate is already loaded in TLSConfig, so ListenAndServeTLS needs no file paths.+ err = server.srv.ListenAndServeTLS("", "")+ } else {+ err = server.srv.ListenAndServe()+ }++ if err != nil && err != http.ErrServerClosed {+ server.logger.ErrorContext(ctx, "failed to start server", errors.Attr(err))+ return err}return nil}diff --git a/pkg/http/server/server_test.go b/pkg/http/server/server_test.gonew file mode 100644index 0000000000..de559b29d7--- /dev/null+++ b/pkg/http/server/server_test.go@@ -0,0 +1,243 @@+package server++import (+ "context"+ "crypto/ecdsa"+ "crypto/elliptic"+ "crypto/rand"+ "crypto/tls"+ "crypto/x509"+ "crypto/x509/pkix"+ "encoding/pem"+ "io"+ "log/slog"+ "math/big"+ "net"+ "net/http"+ "os"+ "path/filepath"+ "testing"+ "time"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestNew(t *testing.T) {+ logger := slog.New(slog.DiscardHandler)+ handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})+ certFile, keyFile := writeSelfSignedCert(t)++ corruptFile := filepath.Join(t.TempDir(), "corrupt.crt")+ require.NoError(t, os.WriteFile(corruptFile, []byte("not a pem"), 0o644))++ testCases := []struct {+ name string+ config Config+ err bool+ minVersion uint16+ }{+ {+ name: "TLSDisabled",+ config: Config{},+ },+ {+ name: "TLSDisabled_WithCertAndKey",+ config: Config{TLS: TLS{CertFile: "ignored.crt", KeyFile: "ignored.key"}},+ },+ {+ name: "TLSEnabled_WithoutCertAndKey",+ config: Config{TLS: TLS{Enabled: true}},+ err: true,+ },+ {+ name: "TLSEnabled_WithoutKey",+ config: Config{TLS: TLS{Enabled: true, CertFile: "server.crt"}},+ err: true,+ },+ {+ name: "TLSEnabled_WithoutCert",+ config: Config{TLS: TLS{Enabled: true, KeyFile: "server.key"}},+ err: true,+ },+ {+ name: "TLSEnabled_InvalidMinVersion",+ config: Config{TLS: TLS{Enabled: true, CertFile: "tls.crt", KeyFile: "tls.key", MinVersion: "1.1"}},+ err: true,+ },+ {+ name: "TLSEnabled_MissingFiles",+ config: Config{TLS: TLS{Enabled: true, CertFile: "missing.crt", KeyFile: "missing.key"}},+ err: true,+ },+ {+ name: "TLSEnabled_CorruptCertFile",+ config: Config{TLS: TLS{Enabled: true, CertFile: corruptFile, KeyFile: keyFile}},+ err: true,+ },+ {+ name: "TLSEnabled_DefaultVersions",+ config: Config{TLS: TLS{Enabled: true, CertFile: certFile, KeyFile: keyFile}},+ },+ {+ name: "TLSEnabled_WithMin",+ config: Config{TLS: TLS{Enabled: true, CertFile: certFile, KeyFile: keyFile, MinVersion: "1.3"}},+ minVersion: tls.VersionTLS13,+ },+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ server, err := New(logger, testCase.config, handler)+ if testCase.err {+ assert.Error(t, err)+ return+ }++ require.NoError(t, err)+ if !testCase.config.TLS.Enabled {+ assert.Nil(t, server.srv.TLSConfig)+ return+ }++ require.NotNil(t, server.srv.TLSConfig)+ assert.Len(t, server.srv.TLSConfig.Certificates, 1)+ assert.Equal(t, testCase.minVersion, server.srv.TLSConfig.MinVersion)+ })+ }+}++func TestStartWithTLS(t *testing.T) {+ certFile, keyFile := writeSelfSignedCert(t)+ addr := freeAddr(t)++ server, err := New(+ slog.New(slog.DiscardHandler),+ Config{Address: addr, TLS: TLS{Enabled: true, CertFile: certFile, KeyFile: keyFile}},+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("ok")) }),+ )+ require.NoError(t, err)++ errC := make(chan error, 1)+ go func() { errC <- server.Start(context.Background()) }()++ certPEM, err := os.ReadFile(certFile)+ require.NoError(t, err)+ pool := x509.NewCertPool()+ require.True(t, pool.AppendCertsFromPEM(certPEM))+ client := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{RootCAs: pool}}}++ var (+ statusCode int+ body []byte+ tlsVersion uint16+ )+ require.Eventually(t, func() bool {+ resp, err := client.Get("https://" + addr)+ if err != nil {+ return false+ }+ defer func() { _ = resp.Body.Close() }()++ body, err = io.ReadAll(resp.Body)+ if err != nil {+ return false+ }++ statusCode = resp.StatusCode+ if resp.TLS != nil {+ tlsVersion = resp.TLS.Version+ }+ return true+ }, 5*time.Second, 25*time.Millisecond)++ assert.Equal(t, http.StatusOK, statusCode)+ assert.Equal(t, "ok", string(body))+ assert.GreaterOrEqual(t, tlsVersion, uint16(tls.VersionTLS12))++ plainResp, err := http.Get("http://" + addr)+ require.NoError(t, err)+ _ = plainResp.Body.Close()+ assert.Equal(t, http.StatusBadRequest, plainResp.StatusCode)++ require.NoError(t, server.Stop(context.Background()))+ require.NoError(t, <-errC)+}++func TestStartWithoutTLS(t *testing.T) {+ addr := freeAddr(t)++ server, err := New(+ slog.New(slog.DiscardHandler),+ Config{Address: addr},+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("pong")) }),+ )+ require.NoError(t, err)++ errC := make(chan error, 1)+ go func() { errC <- server.Start(context.Background()) }()++ var (+ statusCode int+ tlsNegotiated bool+ )+ require.Eventually(t, func() bool {+ resp, err := http.Get("http://" + addr)+ if err != nil {+ return false+ }+ defer func() { _ = resp.Body.Close() }()++ statusCode = resp.StatusCode+ tlsNegotiated = resp.TLS != nil+ return true+ }, 5*time.Second, 25*time.Millisecond)++ assert.Equal(t, http.StatusOK, statusCode)+ assert.False(t, tlsNegotiated)++ require.NoError(t, server.Stop(context.Background()))+ require.NoError(t, <-errC)+}++func freeAddr(t *testing.T) string {+ t.Helper()++ listener, err := net.Listen("tcp", "127.0.0.1:0")+ require.NoError(t, err)+ defer func() { _ = listener.Close() }()++ return listener.Addr().String()+}++func writeSelfSignedCert(t *testing.T) (string, string) {+ t.Helper()++ key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)+ require.NoError(t, err)++ template := &x509.Certificate{+ SerialNumber: big.NewInt(1),+ Subject: pkix.Name{CommonName: "localhost"},+ NotBefore: time.Now().Add(-time.Hour),+ NotAfter: time.Now().Add(time.Hour),+ KeyUsage: x509.KeyUsageDigitalSignature,+ ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},+ IPAddresses: []net.IP{net.ParseIP("127.0.0.1")},+ }++ der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)+ require.NoError(t, err)++ keyDER, err := x509.MarshalECPrivateKey(key)+ require.NoError(t, err)++ dir := t.TempDir()+ certFile := filepath.Join(dir, "server.crt")+ keyFile := filepath.Join(dir, "server.key")++ require.NoError(t, os.WriteFile(certFile, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}), 0o644))+ require.NoError(t, os.WriteFile(keyFile, pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER}), 0o600))++ return certFile, keyFile+}