chore: remove comment

docs/api/openapi.yml

@@ -2646,6 +2646,54 @@ components:
         repeatVariable:
           type: string
       type: object
+    DashboardtypesAreaChartAppearance:
+      properties:
+        fillMode:
+          $ref: '#/components/schemas/DashboardtypesAreaFillMode'
+        fillOpacity:
+          $ref: '#/components/schemas/DashboardtypesFillOpacity'
+        lineInterpolation:
+          $ref: '#/components/schemas/DashboardtypesLineInterpolation'
+        lineStyle:
+          $ref: '#/components/schemas/DashboardtypesLineStyle'
+        showPoints:
+          type: boolean
+        spanGaps:
+          $ref: '#/components/schemas/DashboardtypesSpanGaps'
+      type: object
+    DashboardtypesAreaChartPanelSpec:
+      properties:
+        axes:
+          $ref: '#/components/schemas/DashboardtypesAxes'
+        chartAppearance:
+          $ref: '#/components/schemas/DashboardtypesAreaChartAppearance'
+        formatting:
+          $ref: '#/components/schemas/DashboardtypesPanelFormatting'
+        legend:
+          $ref: '#/components/schemas/DashboardtypesLegend'
+        thresholds:
+          items:
+            $ref: '#/components/schemas/DashboardtypesThresholdWithLabel'
+          nullable: true
+          type: array
+        visualization:
+          $ref: '#/components/schemas/DashboardtypesAreaChartVisualization'
+      type: object
+    DashboardtypesAreaChartVisualization:
+      properties:
+        fillSpans:
+          type: boolean
+        stack:
+          $ref: '#/components/schemas/DashboardtypesStackMode'
+        timePreference:
+          $ref: '#/components/schemas/DashboardtypesTimePreference'
+      type: object
+    DashboardtypesAreaFillMode:
+      enum:
+      - solid
+      - gradient
+      - none
+      type: string
     DashboardtypesAxes:
       properties:
         isLogScale:
@@ -2877,6 +2925,11 @@ components:
       - gradient
       - none
       type: string
+    DashboardtypesFillOpacity:
+      maximum: 1
+      minimum: 0
+      nullable: true
+      type: number
     DashboardtypesGettableDashboardV2:
       properties:
         createdAt:
@@ -3294,6 +3347,7 @@ components:
     DashboardtypesPanelPlugin:
       discriminator:
         mapping:
+          signoz/AreaChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec'
           signoz/BarChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec'
           signoz/HistogramPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec'
           signoz/ListPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'
@@ -3305,6 +3359,7 @@ components:
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec'
+      - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'
@@ -3315,12 +3370,25 @@ components:
       enum:
       - signoz/TimeSeriesPanel
       - signoz/BarChartPanel
+      - signoz/AreaChartPanel
       - signoz/NumberPanel
       - signoz/PieChartPanel
       - signoz/TablePanel
       - signoz/HistogramPanel
       - signoz/ListPanel
       type: string
+    DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec:
+      properties:
+        kind:
+          enum:
+          - signoz/AreaChartPanel
+          type: string
+        spec:
+          $ref: '#/components/schemas/DashboardtypesAreaChartPanelSpec'
+      required:
+      - kind
+      - spec
+      type: object
     DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec:
       properties:
         kind:
@@ -3639,6 +3707,12 @@ components:
             are connected.
           type: boolean
       type: object
+    DashboardtypesStackMode:
+      enum:
+      - none
+      - normal
+      - percent
+      type: string
     DashboardtypesStorableDashboardData:
       additionalProperties: {}
       type: object

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -1274,6 +1274,264 @@ func TestTimeSeriesPanelDefaults(t *testing.T) {
 	}
 }
 
+func TestAreaChartPanelDefaults(t *testing.T) {
+	data := []byte(`{
+		"variables": [],
+		"panels": {
+			"p1": {
+				"kind": "Panel",
+				"spec": {
+					"links": [],
+					"plugin": {
+						"kind": "signoz/AreaChartPanel",
+						"spec": {}
+					},
+					"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+				}
+			}
+		},
+		"links": [],
+		"layouts": []
+	}`)
+	d, err := unmarshalDashboard(data)
+	require.NoError(t, err, "unmarshal and validate failed")
+
+	require.IsType(t, &AreaChartPanelSpec{}, d.Panels["p1"].Spec.Plugin.Spec)
+	spec := d.Panels["p1"].Spec.Plugin.Spec.(*AreaChartPanelSpec)
+
+	assert.Equal(t, "solid", spec.ChartAppearance.FillMode.ValueOrDefault(), "area fillMode defaults to solid, where the TimeSeries FillMode defaults to none")
+	assert.Nil(t, spec.ChartAppearance.FillOpacity, "an omitted fillOpacity stays nil so the renderer applies the kind default")
+	assert.Equal(t, "none", spec.Visualization.Stack.ValueOrDefault(), "expected Stack default none")
+	assert.Equal(t, "2", spec.Formatting.DecimalPrecision.ValueOrDefault(), "expected DecimalPrecision default 2")
+	assert.Equal(t, "spline", spec.ChartAppearance.LineInterpolation.ValueOrDefault(), "expected LineInterpolation default spline")
+	assert.Equal(t, "solid", spec.ChartAppearance.LineStyle.ValueOrDefault(), "expected LineStyle default solid")
+	assert.Equal(t, "global_time", spec.Visualization.TimePreference.ValueOrDefault(), "expected TimePreference default global_time")
+	assert.Equal(t, "bottom", spec.Legend.Position.ValueOrDefault(), "expected LegendPosition default bottom")
+	assert.Equal(t, "list", spec.Legend.Mode.ValueOrDefault(), "expected LegendMode default list")
+
+	output, err := json.Marshal(d)
+	require.NoError(t, err, "marshal dashboard failed")
+	outputStr := string(output)
+	for field, want := range map[string]string{
+		"fillMode":    `"solid"`,
+		"stack":       `"none"`,
+		"fillOpacity": `null`,
+	} {
+		assert.Contains(t, outputStr, `"`+field+`":`+want, "expected stored/response JSON to contain %s:%s", field, want)
+	}
+}
+
+func TestAreaChartPanelRoundTrip(t *testing.T) {
+	data := []byte(`{
+		"variables": [],
+		"panels": {
+			"p1": {
+				"kind": "Panel",
+				"spec": {
+					"links": [],
+					"plugin": {
+						"kind": "signoz/AreaChartPanel",
+						"spec": {
+							"visualization": {"timePreference": "global_time", "fillSpans": false, "stack": "percent"},
+							"chartAppearance": {"fillMode": "gradient", "fillOpacity": 0.4}
+						}
+					},
+					"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+				}
+			}
+		},
+		"links": [],
+		"layouts": []
+	}`)
+	d, err := unmarshalDashboard(data)
+	require.NoError(t, err, "unmarshal and validate failed")
+
+	require.IsType(t, &AreaChartPanelSpec{}, d.Panels["p1"].Spec.Plugin.Spec)
+	spec := d.Panels["p1"].Spec.Plugin.Spec.(*AreaChartPanelSpec)
+
+	assert.Equal(t, "percent", spec.Visualization.Stack.ValueOrDefault(), "expected stack percent")
+	assert.Equal(t, "gradient", spec.ChartAppearance.FillMode.ValueOrDefault(), "expected fillMode gradient")
+
+	output, err := json.Marshal(d)
+	require.NoError(t, err, "marshal dashboard failed")
+	assert.Contains(t, string(output), `"stack":"percent"`, "expected stack in stored/response JSON")
+	assert.Contains(t, string(output), `"fillMode":"gradient"`, "expected fillMode in stored/response JSON")
+}
+
+func TestAreaChartPanelFillOpacity(t *testing.T) {
+	tests := []struct {
+		scenario                 string
+		chartAppearance          string
+		expectedFillOpacitySet   bool
+		expectedFillOpacityValue FillOpacity
+		expectedMarshalledJSON   string
+	}{
+		{
+			scenario:                 "zero is a set value, not an absent one",
+			chartAppearance:          `{"fillOpacity": 0}`,
+			expectedFillOpacitySet:   true,
+			expectedFillOpacityValue: 0,
+			expectedMarshalledJSON:   `"fillOpacity":0`,
+		},
+		{
+			scenario:                 "fully opaque upper bound",
+			chartAppearance:          `{"fillOpacity": 1}`,
+			expectedFillOpacitySet:   true,
+			expectedFillOpacityValue: 1,
+			expectedMarshalledJSON:   `"fillOpacity":1`,
+		},
+		{
+			scenario:                 "typical fractional value",
+			chartAppearance:          `{"fillOpacity": 0.4}`,
+			expectedFillOpacitySet:   true,
+			expectedFillOpacityValue: 0.4,
+			expectedMarshalledJSON:   `"fillOpacity":0.4`,
+		},
+		{
+			scenario:                 "precision beyond one decimal place survives",
+			chartAppearance:          `{"fillOpacity": 0.125}`,
+			expectedFillOpacitySet:   true,
+			expectedFillOpacityValue: 0.125,
+			expectedMarshalledJSON:   `"fillOpacity":0.125`,
+		},
+		{
+			scenario:               "omitted field stays nil so the renderer applies the kind default",
+			chartAppearance:        `{}`,
+			expectedFillOpacitySet: false,
+			expectedMarshalledJSON: `"fillOpacity":null`,
+		},
+		{
+			scenario:               "explicit null stays nil rather than decoding as zero",
+			chartAppearance:        `{"fillOpacity": null}`,
+			expectedFillOpacitySet: false,
+			expectedMarshalledJSON: `"fillOpacity":null`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.scenario, func(t *testing.T) {
+			data := []byte(`{
+				"variables": [],
+				"panels": {
+					"p1": {
+						"kind": "Panel",
+						"spec": {
+							"links": [],
+							"plugin": {"kind": "signoz/AreaChartPanel", "spec": {"chartAppearance": ` + test.chartAppearance + `}},
+							"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+						}
+					}
+				},
+				"links": [],
+				"layouts": []
+			}`)
+			d, err := unmarshalDashboard(data)
+			require.NoError(t, err, "unmarshal and validate failed")
+
+			require.IsType(t, &AreaChartPanelSpec{}, d.Panels["p1"].Spec.Plugin.Spec)
+			spec := d.Panels["p1"].Spec.Plugin.Spec.(*AreaChartPanelSpec)
+
+			if !test.expectedFillOpacitySet {
+				assert.Nil(t, spec.ChartAppearance.FillOpacity, "expected fillOpacity to stay unset")
+			} else {
+				require.NotNil(t, spec.ChartAppearance.FillOpacity, "expected fillOpacity to decode as a set value")
+				assert.Equal(t, test.expectedFillOpacityValue, *spec.ChartAppearance.FillOpacity, "unexpected decoded fillOpacity")
+			}
+
+			output, err := json.Marshal(d)
+			require.NoError(t, err, "marshal dashboard failed")
+			assert.Contains(t, string(output), test.expectedMarshalledJSON, "unexpected fillOpacity in stored/response JSON")
+		})
+	}
+}
+
+func TestInvalidateAreaChartPanelSpecValues(t *testing.T) {
+	tests := []struct {
+		scenario               string
+		panelKind              string
+		panelSpec              string
+		expectedErrorSubstring string
+	}{
+		{
+			scenario:               "unknown stack mode",
+			panelKind:              "signoz/AreaChartPanel",
+			panelSpec:              `{"visualization": {"stack": "stacked"}}`,
+			expectedErrorSubstring: "stack mode",
+		},
+		{
+			scenario:               "unknown area fill mode",
+			panelKind:              "signoz/AreaChartPanel",
+			panelSpec:              `{"chartAppearance": {"fillMode": "striped"}}`,
+			expectedErrorSubstring: "fill mode",
+		},
+		{
+			scenario:               "fill opacity on a 0-100 scale",
+			panelKind:              "signoz/AreaChartPanel",
+			panelSpec:              `{"chartAppearance": {"fillOpacity": 40}}`,
+			expectedErrorSubstring: "invalid fillOpacity 40: must be between 0 and 1",
+		},
+		{
+			scenario:               "negative fill opacity",
+			panelKind:              "signoz/AreaChartPanel",
+			panelSpec:              `{"chartAppearance": {"fillOpacity": -0.5}}`,
+			expectedErrorSubstring: "invalid fillOpacity -0.5: must be between 0 and 1",
+		},
+		{
+			scenario:               "non-numeric fill opacity",
+			panelKind:              "signoz/AreaChartPanel",
+			panelSpec:              `{"chartAppearance": {"fillOpacity": "0.4"}}`,
+			expectedErrorSubstring: "cannot unmarshal string",
+		},
+		{
+			scenario:               "stack on a time series panel",
+			panelKind:              "signoz/TimeSeriesPanel",
+			panelSpec:              `{"visualization": {"stack": "normal"}}`,
+			expectedErrorSubstring: `unknown field`,
+		},
+		{
+			scenario:               "fill opacity on a time series panel",
+			panelKind:              "signoz/TimeSeriesPanel",
+			panelSpec:              `{"chartAppearance": {"fillOpacity": 0.4}}`,
+			expectedErrorSubstring: `unknown field`,
+		},
+		{
+			scenario:               "stacked bar chart on an area panel",
+			panelKind:              "signoz/AreaChartPanel",
+			panelSpec:              `{"visualization": {"stackedBarChart": true}}`,
+			expectedErrorSubstring: `unknown field`,
+		},
+		{
+			scenario:               "stack on a bar chart panel",
+			panelKind:              "signoz/BarChartPanel",
+			panelSpec:              `{"visualization": {"stack": "percent"}}`,
+			expectedErrorSubstring: `unknown field`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.scenario, func(t *testing.T) {
+			data := []byte(`{
+				"variables": [],
+				"panels": {
+					"p1": {
+						"kind": "Panel",
+						"spec": {
+							"links": [],
+							"plugin": {"kind": "` + test.panelKind + `", "spec": ` + test.panelSpec + `},
+							"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+						}
+					}
+				},
+				"links": [],
+				"layouts": []
+			}`)
+			_, err := unmarshalDashboard(data)
+			require.Error(t, err, "expected the spec to be rejected")
+			assert.Contains(t, err.Error(), test.expectedErrorSubstring, "unexpected error message: %s", err.Error())
+		})
+	}
+}
+
 func TestNumberPanelDefaults(t *testing.T) {
 	data := []byte(`{
 		"variables": [],

pkg/types/dashboardtypes/perses_plugin_wrappers.go

@@ -30,6 +30,7 @@ func (PanelPlugin) PrepareJSONSchema(s *jsonschema.Schema) error {
 	return markDiscriminator(s, "kind", map[string]string{
 		string(PanelKindTimeSeries): schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec"),
 		string(PanelKindBarChart):   schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec"),
+		string(PanelKindAreaChart):  schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAreaChartPanelSpec"),
 		string(PanelKindNumber):     schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec"),
 		string(PanelKindPieChart):   schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec"),
 		string(PanelKindTable):      schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec"),
@@ -60,6 +61,7 @@ func (PanelPlugin) JSONSchemaOneOf() []any {
 	return []any{
 		PanelPluginVariant[TimeSeriesPanelSpec]{Kind: string(PanelKindTimeSeries)},
 		PanelPluginVariant[BarChartPanelSpec]{Kind: string(PanelKindBarChart)},
+		PanelPluginVariant[AreaChartPanelSpec]{Kind: string(PanelKindAreaChart)},
 		PanelPluginVariant[NumberPanelSpec]{Kind: string(PanelKindNumber)},
 		PanelPluginVariant[PieChartPanelSpec]{Kind: string(PanelKindPieChart)},
 		PanelPluginVariant[TablePanelSpec]{Kind: string(PanelKindTable)},
@@ -223,6 +225,7 @@ var (
 	panelPluginSpecs = map[PanelPluginKind]func() any{
 		PanelKindTimeSeries: func() any { return new(TimeSeriesPanelSpec) },
 		PanelKindBarChart:   func() any { return new(BarChartPanelSpec) },
+		PanelKindAreaChart:  func() any { return new(AreaChartPanelSpec) },
 		PanelKindNumber:     func() any { return new(NumberPanelSpec) },
 		PanelKindPieChart:   func() any { return new(PieChartPanelSpec) },
 		PanelKindTable:      func() any { return new(TablePanelSpec) },
@@ -245,6 +248,7 @@ var (
 	allowedQueryKinds = map[PanelPluginKind][]QueryPluginKind{
 		PanelKindTimeSeries: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
 		PanelKindBarChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindAreaChart:  {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
 		PanelKindNumber:     {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
 		PanelKindHistogram:  {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
 		PanelKindPieChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},

pkg/types/dashboardtypes/perses_public_dashboard.go

@@ -183,7 +183,8 @@ func (d *DashboardV2) GetPanelQuery(startTime, endTime uint64, panelKey string)
 		return nil, err
 	}
 
-	// fillGaps lives on the panel visualization; only timeseries and bar chart carry it.
+	// fillGaps lives on the panel visualization; only timeseries, bar chart and
+	// area chart carry it.
 	fillGaps := false
 	switch panelSpec := panel.Spec.Plugin.Spec.(type) {
 	case *TimeSeriesPanelSpec:
@@ -194,6 +195,10 @@ func (d *DashboardV2) GetPanelQuery(startTime, endTime uint64, panelKey string)
 		if panelSpec != nil {
 			fillGaps = panelSpec.Visualization.FillSpans
 		}
+	case *AreaChartPanelSpec:
+		if panelSpec != nil {
+			fillGaps = panelSpec.Visualization.FillSpans
+		}
 	}
 
 	return &qb.QueryRangeRequest{

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -168,6 +168,7 @@ type PanelPluginKind string
 const (
 	PanelKindTimeSeries PanelPluginKind = "signoz/TimeSeriesPanel"
 	PanelKindBarChart   PanelPluginKind = "signoz/BarChartPanel"
+	PanelKindAreaChart  PanelPluginKind = "signoz/AreaChartPanel"
 	PanelKindNumber     PanelPluginKind = "signoz/NumberPanel"
 	PanelKindPieChart   PanelPluginKind = "signoz/PieChartPanel"
 	PanelKindTable      PanelPluginKind = "signoz/TablePanel"
@@ -176,7 +177,7 @@ const (
 )
 
 func (PanelPluginKind) Enum() []any {
-	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList}
+	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindAreaChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList}
 }
 
 type TimeSeriesPanelSpec struct {
@@ -204,6 +205,30 @@ type BarChartPanelSpec struct {
 	Thresholds    []ThresholdWithLabel  `json:"thresholds" validate:"dive"`
 }
 
+type AreaChartPanelSpec struct {
+	Visualization   AreaChartVisualization `json:"visualization"`
+	Formatting      PanelFormatting        `json:"formatting"`
+	ChartAppearance AreaChartAppearance    `json:"chartAppearance"`
+	Axes            Axes                   `json:"axes"`
+	Legend          Legend                 `json:"legend"`
+	Thresholds      []ThresholdWithLabel   `json:"thresholds" validate:"dive"`
+}
+
+// AreaChartAppearance repeats the line-drawing fields rather than embedding
+// TimeSeriesChartAppearance: both carry a `fillMode` under different enums, and
+// a duplicated json tag across an embed boundary is resolved by depth, which the
+// schema reflector does not model.
+type AreaChartAppearance struct {
+	LineInterpolation LineInterpolation `json:"lineInterpolation"`
+	ShowPoints        bool              `json:"showPoints"`
+	LineStyle         LineStyle         `json:"lineStyle"`
+	FillMode          AreaFillMode      `json:"fillMode"`
+	// FillOpacity is a pointer so an omitted field resolves to the kind default at
+	// render time; a plain value would make the Go zero value a transparent fill.
+	FillOpacity *FillOpacity `json:"fillOpacity"`
+	SpanGaps    SpanGaps     `json:"spanGaps"`
+}
+
 type NumberPanelSpec struct {
 	Visualization BasicVisualization    `json:"visualization"`
 	Formatting    PanelFormatting       `json:"formatting"`
@@ -262,6 +287,12 @@ type BarChartVisualization struct {
 	StackedBarChart bool `json:"stackedBarChart"`
 }
 
+type AreaChartVisualization struct {
+	BasicVisualization
+	FillSpans bool      `json:"fillSpans"`
+	Stack     StackMode `json:"stack"`
+}
+
 type PanelFormatting struct {
 	Unit             string          `json:"unit"`
 	DecimalPrecision PrecisionOption `json:"decimalPrecision"`
@@ -622,6 +653,106 @@ func (fm *FillMode) UnmarshalJSON(data []byte) error {
 	}
 }
 
+type AreaFillMode struct{ valuer.String }
+
+var (
+	AreaFillModeSolid    = AreaFillMode{valuer.NewString("solid")} // default
+	AreaFillModeGradient = AreaFillMode{valuer.NewString("gradient")}
+)
+
+func (AreaFillMode) Enum() []any {
+	return []any{AreaFillModeSolid, AreaFillModeGradient}
+}
+
+func (fm AreaFillMode) ValueOrDefault() string {
+	if fm.IsZero() {
+		return AreaFillModeSolid.StringValue()
+	}
+	return fm.StringValue()
+}
+
+func (fm AreaFillMode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(fm.ValueOrDefault())
+}
+
+func (fm *AreaFillMode) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid fill mode: must be a string, one of `solid`, `gradient`, or `none`")
+	}
+	val := AreaFillMode{valuer.NewString(v)}
+	switch val {
+	case AreaFillModeSolid, AreaFillModeGradient:
+		*fm = val
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid fill mode %q: must be `solid`, `gradient`, or `none`", v)
+	}
+}
+
+// StackMode is area-only. Bar stacking stays on BarChartVisualization.StackedBarChart,
+// so `percent` is not reachable from a bar panel.
+type StackMode struct{ valuer.String }
+
+var (
+	StackModeNone    = StackMode{valuer.NewString("none")} // default
+	StackModeNormal  = StackMode{valuer.NewString("normal")}
+	StackModePercent = StackMode{valuer.NewString("percent")}
+)
+
+func (StackMode) Enum() []any {
+	return []any{StackModeNone, StackModeNormal, StackModePercent}
+}
+
+func (sm StackMode) ValueOrDefault() string {
+	if sm.IsZero() {
+		return StackModeNone.StringValue()
+	}
+	return sm.StringValue()
+}
+
+func (sm StackMode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(sm.ValueOrDefault())
+}
+
+func (sm *StackMode) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid stack mode: must be a string, one of `none`, `normal`, or `percent`")
+	}
+	val := StackMode{valuer.NewString(v)}
+	switch val {
+	case StackModeNone, StackModeNormal, StackModePercent:
+		*sm = val
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid stack mode %q: must be `none`, `normal`, or `percent`", v)
+	}
+}
+
+// FillOpacity is the alpha of an area fill, in 0–1 because that is what the
+// chart layer consumes directly. Unlike the enums in this section it has no
+// ValueOrDefault: 0 is a legitimate value, so the kind default lives at render
+// time behind a nil pointer.
+type FillOpacity float64
+
+func (FillOpacity) PrepareJSONSchema(s *jsonschema.Schema) error {
+	s.WithMinimum(0).WithMaximum(1)
+	return nil
+}
+
+func (o *FillOpacity) UnmarshalJSON(data []byte) error {
+	var v float64
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid fillOpacity: must be a number between 0 and 1")
+	}
+	if v < 0 || v > 1 {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid fillOpacity %v: must be between 0 and 1", v)
+	}
+	*o = FillOpacity(v)
+	return nil
+}
+
 type SpanGaps struct {
 	FillOnlyBelow bool   `json:"fillOnlyBelow" description:"Controls whether lines connect across null values. When false (default), all gaps are connected. When true, only gaps smaller than fillLessThan are connected."`
 	FillLessThan  string `json:"fillLessThan" description:"The maximum gap size to connect when fillOnlyBelow is true. Gaps larger than this duration are left disconnected."`

pkg/types/dashboardtypes/perses_v1_to_v2.go

@@ -14,6 +14,11 @@ import (
 // (transition.dashboardMigrateV5). Pre-v5 builder queries will produce
 // invalid v2 envelopes — run the v4→v5 migration first.
 //
+// The v1 input shape is closed: nothing writes v1 dashboards any more, so these
+// files only ever convert what v1 could already express. Panel kinds and spec
+// fields added to v2 from here on need no converter entry — change these files
+// only when a v2 type edit breaks the build.
+//
 // The conversion is split across sibling files by concern:
 //   - perses_v1_to_v2_tags.go      tags
 //   - perses_v1_to_v2_panels.go    widgets → panels (+ panel field mappers)

tests/fixtures/alerts.py

@@ -339,37 +339,20 @@ def verify_webhook_notification_expectation(
     notification_channel: types.TestContainerDocker,
     validation_data: dict,
 ) -> bool:
-    """Check that wiremock received the expected request(s) at the given path.
-
-    validation_data supports (all optional except path):
-      - path: request url path (matched as urlPath, so query strings are ignored)
-      - json_body: expected JSON subset of the request body
-      - count: exact number of requests required at the path
-      - min_count: minimum number of requests required (e.g. retries)
-    The body constraint must be satisfied by a single request; count constraints
-    apply to the total at the path."""
+    """Check if wiremock received a request at the given path
+    whose JSON body is a superset of the expected json_body."""
     path = validation_data["path"]
-    json_body = validation_data.get("json_body")
+    json_body = validation_data["json_body"]
 
     url = notification_channel.host_configs["8080"].get("__admin/requests/find")
     try:
-        # urlPath ignores query strings; real webhook urls may carry their own (e.g. key/token).
-        res = requests.post(url, json={"method": "POST", "urlPath": path}, timeout=10)
+        res = requests.post(url, json={"method": "POST", "url": path}, timeout=10)
     except requests.exceptions.RequestException:
         return False
     if res.status_code != HTTPStatus.OK:
         return False
 
-    reqs = res.json()["requests"]
-    if "count" in validation_data and len(reqs) != validation_data["count"]:
-        return False
-    if "min_count" in validation_data and len(reqs) < validation_data["min_count"]:
-        return False
-
-    if json_body is None:
-        return True
-
-    for req in reqs:
+    for req in res.json()["requests"]:
         body = json.loads(base64.b64decode(req["bodyAsBase64"]).decode("utf-8"))
         if _is_json_subset(json_body, body):
             return True
@@ -433,7 +416,7 @@ def _received_notifications(
                 continue
             url = notification_channel.host_configs["8080"].get("__admin/requests/find")
             try:
-                res = requests.post(url, json={"method": "POST", "urlPath": validation.validation_data["path"]}, timeout=10)
+                res = requests.post(url, json={"method": "POST", "url": validation.validation_data["path"]}, timeout=10)
                 webhook_bodies.extend(json.loads(base64.b64decode(req["bodyAsBase64"]).decode("utf-8")) for req in res.json()["requests"])
             except requests.exceptions.RequestException as exc:
                 webhook_bodies.append(f"<failed to fetch wiremock journal: {exc}>")
@@ -472,9 +455,4 @@ def update_raw_channel_config(
                     path = urlparse(original_url).path
                     entry[url_field] = notification_channel.container_configs["8080"].get(path)
 
-    # Google Chat validates the webhook host
-    for entry in config.get("googlechat_configs", []):
-        https = notification_channel.container_configs["443"]
-        entry["webhook_url"] = f"{https.scheme}://{https.address}{urlparse(entry['webhook_url']).path}"
-
     return config

tests/fixtures/notification_channel.py

@@ -1,33 +1,23 @@
 # pylint: disable=line-too-long
 import json
-import re
 import time
-import uuid
 from collections.abc import Callable
 from http import HTTPStatus
-from pathlib import Path
 
 import docker
 import docker.errors
 import pytest
 import requests
 from testcontainers.core.container import Network
-from wiremock.resources.mappings import HttpMethods, Mapping, MappingRequest, MappingResponse
 from wiremock.testing.testcontainer import WireMockContainer
 
 from fixtures import reuse, types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
 from fixtures.logger import setup_logger
 from fixtures.maildev import MAILDEV_INCOMING_PASS, SMTP_TEST_FROM
-from fixtures.tls import CA_ID_LABEL, KEYSTORE_PASSWORD, ca_id, issue_server_keystore
 
 logger = setup_logger(__name__)
 
-# Google Chat validates the webhook host, so the WireMock container joins the
-# network under this alias and serves HTTPS on 443 with a certificate issued by
-# the integration CA that signoz trusts; channels point at https://<host>/...
-GOOGLE_CHAT_HOST = "chat.googleapis.com"
-
 
 EMAIL_TRANSPORT_KEYS = [
     "from",
@@ -134,77 +124,9 @@ email_default_config = {
 }
 
 
-def googlechat_config(space: str) -> dict:
-    """Google Chat channel config for a per-test WireMock space path. Title/text are
-    omitted so the backend applies its default templates. The host is injected at
-    runtime by update_raw_channel_config."""
-    return {
-        "googlechat_configs": [
-            {
-                "webhook_url": f"/v1/spaces/{space}/messages",  # host set on runtime
-            }
-        ],
-    }
-
-
-def googlechat_ok_mappings(path: str) -> list[Mapping]:
-    return [
-        Mapping(
-            request=MappingRequest(method=HttpMethods.POST, url_path=path),
-            response=MappingResponse(status=200, json_body={"name": "spaces/x/messages/x"}),
-        )
-    ]
-
-
-def googlechat_retry_mappings(path: str) -> list[Mapping]:
-    """429 on the first call then 200, via a wiremock scenario transition."""
-    scenario = f"gc-retry-{path}"
-    return [
-        Mapping(
-            request=MappingRequest(method=HttpMethods.POST, url_path=path),
-            response=MappingResponse(status=429, json_body={"error": {"code": 429, "status": "RESOURCE_EXHAUSTED"}}),
-            scenario_name=scenario,
-            required_scenario_state="Started",
-            new_scenario_state="ok",
-        ),
-        Mapping(
-            request=MappingRequest(method=HttpMethods.POST, url_path=path),
-            response=MappingResponse(status=200, json_body={"name": "spaces/x/messages/x"}),
-            scenario_name=scenario,
-            required_scenario_state="ok",
-        ),
-    ]
-
-
-def googlechat_card_subset(alertname: str, buttons: list[tuple[str, str]]) -> dict:
-    """A cardsV2 subset asserting title, firing banner, rendered body, and each
-    button's text AND deep-link url (as a regex), so a broken link is caught too.
-    buttons: list of (text, url_regex)."""
-    return {
-        "text": f"[FIRING:1] {alertname}",
-        "cardsV2": [
-            {
-                "cardId": "signoz-alert",
-                "card": {
-                    "header": {"title": f"[FIRING:1] {alertname}"},
-                    "sections": [
-                        # firing banner
-                        {"widgets": [{"textParagraph": {"text": re.compile("FIRING")}}]},
-                        # rendered alert body mentions the alertname
-                        {"widgets": [{"textParagraph": {"text": re.compile(re.escape(alertname))}}]},
-                    ]
-                    + [{"widgets": [{"buttonList": {"buttons": [{"text": text, "onClick": {"openLink": {"url": re.compile(url)}}}]}}]} for text, url in buttons],
-                },
-            }
-        ],
-    }
-
-
 @pytest.fixture(name="notification_channel", scope="package")
-def notification_channel(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+def notification_channel(
     network: Network,
-    tls: types.TLS,
-    tmpfs: Callable[[str], Path],
     request: pytest.FixtureRequest,
     pytestconfig: pytest.Config,
 ) -> types.TestContainerDocker:
@@ -213,25 +135,9 @@ def notification_channel(  # pylint: disable=too-many-arguments,too-many-positio
     """
 
     def create() -> types.TestContainerDocker:
-        # http:8080 for admin API + plain webhook delivery; https:443 aliased as
-        # chat.googleapis.com with a CA-issued cert so Google Chat's validated
-        # webhook host routes here over real TLS (signoz trusts the integration CA).
-        keystore_path = issue_server_keystore(tls, tmpfs("notification-channel-certs"), GOOGLE_CHAT_HOST)
-
         container = WireMockContainer(image="wiremock/wiremock:2.35.1-1", secure=False)
-        container.with_volume_mapping(str(keystore_path.parent), "/certs", "ro")
         container.with_network(network)
-        container.with_network_aliases(GOOGLE_CHAT_HOST)
-        container.with_kwargs(labels={CA_ID_LABEL: ca_id(tls)})
-
-        try:
-            container.start(f"--port 8080 --https-port 443 --https-keystore /certs/keystore.p12 --keystore-type PKCS12 --keystore-password {KEYSTORE_PASSWORD}")
-        except Exception:
-            # Ryuk is disabled: a started-but-unready container would survive and
-            # keep squatting on the chat.googleapis.com alias, poisoning DNS for
-            # any replacement on the shared network.
-            container.stop()
-            raise
+        container.start()
 
         return types.TestContainerDocker(
             id=container.get_wrapped_container().id,
@@ -242,11 +148,7 @@ def notification_channel(  # pylint: disable=too-many-arguments,too-many-positio
                     container.get_exposed_port(8080),
                 )
             },
-            container_configs={
-                "8080": types.TestContainerUrlConfig("http", container.get_wrapped_container().name, 8080),
-                # Google Chat delivery: https to the validated host via the network alias.
-                "443": types.TestContainerUrlConfig("https", GOOGLE_CHAT_HOST, 443),
-            },
+            container_configs={"8080": types.TestContainerUrlConfig("http", container.get_wrapped_container().name, 8080)},
         )
 
     def delete(container: types.TestContainerDocker):
@@ -263,16 +165,6 @@ def notification_channel(  # pylint: disable=too-many-arguments,too-many-positio
     def restore(cache: dict) -> types.TestContainerDocker:
         return types.TestContainerDocker.from_cache(cache)
 
-    def stale(container: types.TestContainerDocker) -> bool:
-        # A container built against a rotated/absent CA can't serve a cert signoz
-        # trusts; recreate it instead of failing TLS opaquely.
-        client = docker.from_env()
-        try:
-            labels = client.containers.get(container_id=container.id).attrs["Config"]["Labels"]
-        except docker.errors.NotFound:
-            return True
-        return labels.get(CA_ID_LABEL) != ca_id(tls)
-
     return reuse.wrap(
         request,
         pytestconfig,
@@ -281,7 +173,6 @@ def notification_channel(  # pylint: disable=too-many-arguments,too-many-positio
         create,
         delete,
         restore,
-        stale=stale,
     )
 
 
@@ -357,31 +248,6 @@ def create_webhook_notification_channel(
     return _create_webhook_notification_channel
 
 
-def wait_for_org_registration(signoz: types.SigNoz, token: str, notification_channel: types.TestContainerDocker, wait_seconds: int = 60) -> None:
-    """Polls until the org's alertmanager server is registered (one poll tick).
-
-    channels/test 404s until then, before reaching any notifier. The sentinel
-    receiver posts to its own unstubbed wiremock path, so request journals
-    asserted by tests stay clean."""
-    sentinel = {
-        "name": str(uuid.uuid4()),
-        "webhook_configs": [{"url": notification_channel.container_configs["8080"].get("/org-registration-sentinel")}],
-    }
-    deadline = time.time() + wait_seconds
-    last = None
-    while time.time() < deadline:
-        last = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v1/channels/test"),
-            json=sentinel,
-            headers={"Authorization": f"Bearer {token}"},
-            timeout=30,
-        )
-        if last.status_code != HTTPStatus.NOT_FOUND:
-            return
-        time.sleep(2)
-    raise AssertionError(f"org alertmanager did not register within {wait_seconds}s, last response: {last.status_code} {last.text}")
-
-
 def send_test_notification(signoz: types.SigNoz, token: str, receiver: dict, wait_seconds: int = 90) -> None:
     deadline = time.time() + wait_seconds
     last = None

tests/integration/tests/alertmanager/04_googlechat.py

@@ -1,187 +0,0 @@
-import json
-import uuid
-from collections.abc import Callable
-from datetime import UTC, datetime, timedelta
-
-import pytest
-from wiremock.resources.mappings import Mapping
-
-from fixtures import types
-from fixtures.alerts import (
-    get_testdata_file_path,
-    update_raw_channel_config,
-    update_rule_channel_name,
-    verify_notification_expectation,
-)
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.logger import setup_logger
-from fixtures.notification_channel import (
-    googlechat_card_subset,
-    googlechat_config,
-    googlechat_ok_mappings,
-    googlechat_retry_mappings,
-    wait_for_org_registration,
-)
-
-logger = setup_logger(__name__)
-
-METRICS_DATA = "alerts/test_scenarios/threshold_above_at_least_once/alert_data.jsonl"
-METRICS_RULE = "alerts/test_scenarios/threshold_above_at_least_once/rule.json"
-LOGS_DATA = "alerts/test_scenarios/threshold_below_at_least_once/alert_data.jsonl"
-LOGS_RULE = "alerts/test_scenarios/threshold_below_at_least_once/rule.json"
-TRACES_DATA = "alerts/test_scenarios/threshold_above_average/alert_data.jsonl"
-TRACES_RULE = "alerts/test_scenarios/threshold_above_average/rule.json"
-
-
-GOOGLECHAT_CASES = [
-    types.AlertManagerNotificationTestCase(
-        name="googlechat_default_metrics_firing",
-        rule_path=METRICS_RULE,
-        alert_data=[types.AlertData(type="metrics", data_path=METRICS_DATA)],
-        channel_config=googlechat_config("gc-metrics"),
-        notification_expectation=types.AMNotificationExpectation(
-            should_notify=True,
-            wait_time_seconds=60,
-            notification_validations=[
-                types.NotificationValidation(
-                    destination_type="webhook",
-                    validation_data={
-                        "path": "/v1/spaces/gc-metrics/messages",
-                        "count": 1,
-                        "json_body": googlechat_card_subset("threshold_above_at_least_once", [("Open in SigNoz", r"/alerts/overview\?ruleId=")]),
-                    },
-                ),
-            ],
-        ),
-    ),
-    types.AlertManagerNotificationTestCase(
-        name="googlechat_rich_card_logs",
-        rule_path=LOGS_RULE,
-        alert_data=[types.AlertData(type="logs", data_path=LOGS_DATA)],
-        channel_config=googlechat_config("gc-logs"),
-        notification_expectation=types.AMNotificationExpectation(
-            should_notify=True,
-            wait_time_seconds=60,
-            notification_validations=[
-                types.NotificationValidation(
-                    destination_type="webhook",
-                    validation_data={
-                        "path": "/v1/spaces/gc-logs/messages",
-                        "count": 1,
-                        "json_body": googlechat_card_subset(
-                            "threshold_below_at_least_once",
-                            [("View Related Logs", r"/logs/logs-explorer\?"), ("Open in SigNoz", r"/alerts/overview\?ruleId=")],
-                        ),
-                    },
-                ),
-            ],
-        ),
-    ),
-    types.AlertManagerNotificationTestCase(
-        name="googlechat_rich_card_traces",
-        rule_path=TRACES_RULE,
-        alert_data=[types.AlertData(type="traces", data_path=TRACES_DATA)],
-        channel_config=googlechat_config("gc-traces"),
-        notification_expectation=types.AMNotificationExpectation(
-            should_notify=True,
-            wait_time_seconds=60,
-            notification_validations=[
-                types.NotificationValidation(
-                    destination_type="webhook",
-                    validation_data={
-                        "path": "/v1/spaces/gc-traces/messages",
-                        "count": 1,
-                        "json_body": googlechat_card_subset(
-                            "threshold_above_average",
-                            [("View Related Traces", r"traces-explorer\?"), ("Open in SigNoz", r"/alerts/overview\?ruleId=")],
-                        ),
-                    },
-                ),
-            ],
-        ),
-    ),
-]
-
-
-@pytest.mark.parametrize(
-    "gc_test_case",
-    GOOGLECHAT_CASES,
-    ids=lambda c: c.name,
-)
-def test_googlechat_notifier(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    signoz: types.SigNoz,
-    get_token: Callable[[str, str], str],
-    notification_channel: types.TestContainerDocker,
-    make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],
-    create_notification_channel: Callable[[dict], str],
-    create_alert_rule: Callable[[dict], str],
-    insert_alert_data: Callable[[list[types.AlertData], datetime], None],
-    maildev: types.TestContainerDocker,
-    gc_test_case: types.AlertManagerNotificationTestCase,
-) -> None:
-    channel_name = str(uuid.uuid4())
-    path = gc_test_case.notification_expectation.notification_validations[0].validation_data["path"]
-
-    channel_config = update_raw_channel_config(gc_test_case.channel_config, channel_name, notification_channel)
-
-    make_http_mocks(notification_channel, googlechat_ok_mappings(path))
-
-    create_notification_channel(channel_config)
-    wait_for_org_registration(signoz, get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD), notification_channel)
-
-    insert_alert_data(gc_test_case.alert_data, base_time=datetime.now(tz=UTC) - timedelta(minutes=5))
-
-    with open(get_testdata_file_path(gc_test_case.rule_path), encoding="utf-8") as f:
-        rule_data = json.loads(f.read())
-    update_rule_channel_name(rule_data, channel_name)
-    create_alert_rule(rule_data)
-
-    verify_notification_expectation(notification_channel, maildev, gc_test_case.notification_expectation)
-
-
-def test_googlechat_retry_429_then_200(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    signoz: types.SigNoz,
-    get_token: Callable[[str, str], str],
-    notification_channel: types.TestContainerDocker,
-    make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],
-    create_notification_channel: Callable[[dict], str],
-    create_alert_rule: Callable[[dict], str],
-    insert_alert_data: Callable[[list[types.AlertData], datetime], None],
-    maildev: types.TestContainerDocker,
-) -> None:
-    channel_name = str(uuid.uuid4())
-    path = "/v1/spaces/gc-retry/messages"
-
-    channel_config = update_raw_channel_config(googlechat_config("gc-retry"), channel_name, notification_channel)
-
-    make_http_mocks(notification_channel, googlechat_retry_mappings(path))
-
-    create_notification_channel(channel_config)
-    wait_for_org_registration(signoz, get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD), notification_channel)
-
-    insert_alert_data([types.AlertData(type="metrics", data_path=METRICS_DATA)], base_time=datetime.now(tz=UTC) - timedelta(minutes=5))
-
-    with open(get_testdata_file_path(METRICS_RULE), encoding="utf-8") as f:
-        rule_data = json.loads(f.read())
-    update_rule_channel_name(rule_data, channel_name)
-    create_alert_rule(rule_data)
-
-    verify_notification_expectation(
-        notification_channel,
-        maildev,
-        types.AMNotificationExpectation(
-            should_notify=True,
-            wait_time_seconds=60,
-            notification_validations=[
-                types.NotificationValidation(
-                    destination_type="webhook",
-                    validation_data={
-                        # a retryable 429 is followed by a successful re-POST => >=2 hits
-                        "path": path,
-                        "min_count": 2,
-                        "json_body": {"cardsV2": [{"cardId": "signoz-alert"}]},
-                    },
-                ),
-            ],
-        ),
-    )

tests/integration/tests/alertmanager/conftest.py

@@ -13,7 +13,6 @@ def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     gateway: types.TestContainerDocker,
     sqlstore: types.TestContainerSQL,
     clickhouse: types.TestContainerClickhouse,
-    tls: types.TLS,
     request: pytest.FixtureRequest,
     pytestconfig: pytest.Config,
     maildev: types.TestContainerDocker,
@@ -25,7 +24,6 @@ def signoz(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         gateway=gateway,
         sqlstore=sqlstore,
         clickhouse=clickhouse,
-        tls=tls,
         request=request,
         pytestconfig=pytestconfig,
         cache_key="signoz_alertmanager",

tests/integration/tests/alerts/02_googlechat_test_channel.py

@@ -1,114 +0,0 @@
-import base64
-import json
-import re
-import time
-import uuid
-from collections.abc import Callable
-from http import HTTPStatus
-from typing import NamedTuple
-
-import pytest
-import requests
-from wiremock.resources.mappings import HttpMethods, Mapping, MappingRequest, MappingResponse
-
-from fixtures import types
-from fixtures.alerts import update_raw_channel_config
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.logger import setup_logger
-from fixtures.notification_channel import googlechat_config
-
-logger = setup_logger(__name__)
-
-
-# channel test (POST /api/v1/channels/test) drives the notifier once, synchronously,
-# with a hardcoded test alert and no retry — the deterministic place to assert
-# permanent-failure behaviour. Rich cards + retry are covered in alertmanager/04_googlechat.py.
-class TestChannelCase(NamedTuple):
-    __test__ = False
-    name: str
-    space: str
-    status: int  # stub status
-    body: dict  # stub body
-    expect_delivered: bool  # expect channels/test 204
-
-
-TEST_CHANNEL_CASES = [
-    TestChannelCase("success", "gc-tc-ok", 200, {"name": "spaces/x/messages/x"}, True),
-    TestChannelCase("permanent_400", "gc-tc-400", 400, {"error": {"code": 400, "status": "INVALID_ARGUMENT", "message": "Message cannot be empty."}}, False),
-    TestChannelCase("permission_403", "gc-tc-403", 403, {"error": {"code": 403, "status": "PERMISSION_DENIED", "message": "Method doesn't allow unregistered callers"}}, False),
-]
-
-
-@pytest.mark.parametrize(
-    "case",
-    TEST_CHANNEL_CASES,
-    ids=lambda c: c.name,
-)
-def test_googlechat_test_channel(  # pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-locals
-    signoz: types.SigNoz,
-    get_token: Callable[[str, str], str],
-    create_user_admin: None,  # pylint: disable=unused-argument
-    notification_channel: types.TestContainerDocker,
-    make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],
-    case: TestChannelCase,
-) -> None:
-    path = f"/v1/spaces/{case.space}/messages"
-    make_http_mocks(
-        notification_channel,
-        [
-            Mapping(
-                request=MappingRequest(method=HttpMethods.POST, url_path=path),
-                response=MappingResponse(status=case.status, json_body=case.body),
-            )
-        ],
-    )
-
-    channel_name = str(uuid.uuid4())
-    receiver = update_raw_channel_config(googlechat_config(case.space), channel_name, notification_channel)
-
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    # channels/test 404s until the org's alertmanager registers (one poll tick),
-    # without reaching the notifier — so the first non-404 response is the single
-    # authoritative delivery attempt and the count == 1 assertion below holds
-    deadline = time.time() + 60
-    while True:
-        response = requests.post(
-            signoz.self.host_configs["8080"].get("/api/v1/channels/test"),
-            json=receiver,
-            headers={"Authorization": f"Bearer {admin_token}"},
-            timeout=30,
-        )
-        if response.status_code != HTTPStatus.NOT_FOUND or time.time() > deadline:
-            break
-        time.sleep(2)
-
-    if case.expect_delivered:
-        assert response.status_code == HTTPStatus.NO_CONTENT, f"expected 204, got {response.status_code}: {response.text}"
-    else:
-        # a downstream 400/403 surfaces as a 500 (untyped notify error) whose body
-        # carries the real downstream status code; pin it to distinguish 400 vs 403
-        assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR, f"expected 500, got {response.status_code}: {response.text}"
-        assert f"unexpected status code {case.status}" in response.text, f"expected downstream {case.status} in error body: {response.text}"
-
-    # exactly one delivery attempt either way (testChannel never retries)
-    count = requests.post(
-        notification_channel.host_configs["8080"].get("/__admin/requests/count"),
-        json={"method": "POST", "urlPath": path},
-        timeout=10,
-    )
-    assert count.json()["count"] == 1, f"expected exactly 1 request (no retry), got {count.text}"
-
-    if case.expect_delivered:
-        find = requests.post(
-            notification_channel.host_configs["8080"].get("/__admin/requests/find"),
-            json={"method": "POST", "urlPath": path},
-            timeout=10,
-        )
-        req = find.json()["requests"][0]
-        # the configured webhook url is posted verbatim, nothing appended
-        assert req["url"] == path, f"expected webhook url {path} posted verbatim, got {req['url']}"
-        # cardsV2 shape with the hardcoded test alert
-        card = json.loads(base64.b64decode(req["bodyAsBase64"]).decode("utf-8"))
-        assert card["cardsV2"][0]["cardId"] == "signoz-alert"
-        assert re.search(r"Test Alert \(", card["cardsV2"][0]["card"]["header"]["title"])