Historical performance tracking and trend analysis will be available soon. This feature will show how your API performance changes over time.
+
+
+
+
+
+
+
+
+ Most Regressed Endpoints
+ Coming Soon
+
+
+
+
+
+
Regression Detection
+
Automatic detection of performance regressions will be available soon. This feature will identify endpoints that have become slower compared to previous runs.
+
+
+
+
+
+
+
+
+
+
+ All Endpoints
+
+
+
+
+
+
+
+
+
+
+
+
+ 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Performance Metrics
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tail Latency Distribution
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Error Distribution
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Request Volume by Endpoint
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Tail Latency Analysis (P99)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Checks Overview
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Filter & Search Checks
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ All Checks
+
+
+
+
+
+
+
+ Check Name
+
+
+ Passes
+
+
+ Fails
+
+
+ Success Rate
+
+
+ Status
+
+
+ Total
+
+
+ Fail Rate
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/reporting/thresholds.go b/reporting/thresholds.go
new file mode 100644
index 00000000..114238a1
--- /dev/null
+++ b/reporting/thresholds.go
@@ -0,0 +1,458 @@
+package reporting
+
+import (
+ "fmt"
+ "os"
+ "regexp"
+ "strconv"
+ "strings"
+ "time"
+
+ "gopkg.in/yaml.v3"
+)
+
+// ThresholdConfig represents the complete threshold configuration
+type ThresholdConfig struct {
+ Defaults ThresholdValues `json:"defaults" yaml:"defaults"`
+ Groups map[string]ThresholdValues `json:"groups" yaml:"groups"`
+ Endpoints map[string]ThresholdValues `json:"endpoints" yaml:"endpoints"`
+ Options ThresholdOptions `json:"options" yaml:"options"`
+}
+
+// ThresholdValues defines the threshold values for various metrics
+type ThresholdValues struct {
+ P50 *DurationThreshold `json:"p50,omitempty" yaml:"p50,omitempty"`
+ P90 *DurationThreshold `json:"p90,omitempty" yaml:"p90,omitempty"`
+ P95 *DurationThreshold `json:"p95,omitempty" yaml:"p95,omitempty"`
+ P99 *DurationThreshold `json:"p99,omitempty" yaml:"p99,omitempty"`
+ Avg *DurationThreshold `json:"avg,omitempty" yaml:"avg,omitempty"`
+ Max *DurationThreshold `json:"max,omitempty" yaml:"max,omitempty"`
+ ErrorRate *RateThreshold `json:"error_rate,omitempty" yaml:"error_rate,omitempty"`
+ RPS *RateThreshold `json:"rps,omitempty" yaml:"rps,omitempty"`
+ MinSamples *int `json:"min_samples,omitempty" yaml:"min_samples,omitempty"`
+}
+
+// DurationThreshold represents a duration-based threshold
+type DurationThreshold struct {
+ Value time.Duration `json:"value" yaml:"value"`
+ Tolerance *float64 `json:"tolerance_percent,omitempty" yaml:"tolerance_percent,omitempty"`
+}
+
+// UnmarshalYAML implements custom YAML unmarshaling for DurationThreshold
+func (dt *DurationThreshold) UnmarshalYAML(value *yaml.Node) error {
+ if value.Kind == yaml.ScalarNode {
+ // Handle string duration like "500ms"
+ durationStr := value.Value
+ duration, err := time.ParseDuration(durationStr)
+ if err != nil {
+ return fmt.Errorf("invalid duration format '%s': %w", durationStr, err)
+ }
+ dt.Value = duration
+ return nil
+ } else if value.Kind == yaml.MappingNode {
+ // Handle object format with value and tolerance
+ var temp struct {
+ Value string `yaml:"value"`
+ Tolerance *float64 `yaml:"tolerance_percent,omitempty"`
+ }
+ if err := value.Decode(&temp); err != nil {
+ return err
+ }
+
+ duration, err := time.ParseDuration(temp.Value)
+ if err != nil {
+ return fmt.Errorf("invalid duration format '%s': %w", temp.Value, err)
+ }
+ dt.Value = duration
+ dt.Tolerance = temp.Tolerance
+ return nil
+ }
+ return fmt.Errorf("invalid DurationThreshold format")
+}
+
+// RateThreshold represents a rate-based threshold (0.0 to 1.0 for rates, any value for RPS)
+type RateThreshold struct {
+ Value float64 `json:"value" yaml:"value"`
+ Tolerance *float64 `json:"tolerance_percent,omitempty" yaml:"tolerance_percent,omitempty"`
+}
+
+// UnmarshalYAML implements custom YAML unmarshaling for RateThreshold
+func (rt *RateThreshold) UnmarshalYAML(value *yaml.Node) error {
+ if value.Kind == yaml.ScalarNode {
+ // Handle numeric value
+ val, err := strconv.ParseFloat(value.Value, 64)
+ if err != nil {
+ return fmt.Errorf("invalid rate value '%s': %w", value.Value, err)
+ }
+ rt.Value = val
+ return nil
+ } else if value.Kind == yaml.MappingNode {
+ // Handle object format with value and tolerance
+ var temp struct {
+ Value float64 `yaml:"value"`
+ Tolerance *float64 `yaml:"tolerance_percent,omitempty"`
+ }
+ if err := value.Decode(&temp); err != nil {
+ return err
+ }
+ rt.Value = temp.Value
+ rt.Tolerance = temp.Tolerance
+ return nil
+ }
+ return fmt.Errorf("invalid RateThreshold format")
+}
+
+// ThresholdOptions defines global options for threshold validation
+type ThresholdOptions struct {
+ TolerancePercent float64 `json:"tolerance_percent" yaml:"tolerance_percent"`
+ MinSamples int `json:"min_samples" yaml:"min_samples"`
+ SoftFail bool `json:"soft_fail" yaml:"soft_fail"`
+}
+
+// ThresholdBreach represents a threshold breach
+type ThresholdBreach struct {
+ Endpoint string `json:"endpoint"`
+ Metric string `json:"metric"`
+ Value float64 `json:"value"`
+ Threshold float64 `json:"threshold"`
+ Unit string `json:"unit"`
+ Severity string `json:"severity"`
+ SampleCount int64 `json:"sample_count"`
+}
+
+// DefaultThresholdConfig returns a sensible default threshold configuration
+func DefaultThresholdConfig() *ThresholdConfig {
+ return &ThresholdConfig{
+ Defaults: ThresholdValues{
+ P95: &DurationThreshold{Value: 500 * time.Millisecond},
+ P99: &DurationThreshold{Value: 1000 * time.Millisecond},
+ Avg: &DurationThreshold{Value: 200 * time.Millisecond},
+ ErrorRate: &RateThreshold{Value: 0.01}, // 1%
+ },
+ Groups: map[string]ThresholdValues{
+ "auth/*": {
+ P95: &DurationThreshold{Value: 350 * time.Millisecond},
+ },
+ "catalog/*": {
+ P95: &DurationThreshold{Value: 450 * time.Millisecond},
+ },
+ },
+ Endpoints: map[string]ThresholdValues{
+ "GET /users": {
+ P95: &DurationThreshold{Value: 300 * time.Millisecond},
+ Avg: &DurationThreshold{Value: 150 * time.Millisecond},
+ },
+ "POST /orders": {
+ P95: &DurationThreshold{Value: 800 * time.Millisecond},
+ Avg: &DurationThreshold{Value: 400 * time.Millisecond},
+ },
+ },
+ Options: ThresholdOptions{
+ TolerancePercent: 10.0, // 10% tolerance by default
+ MinSamples: 100, // Require at least 100 samples for reliable percentiles
+ SoftFail: false,
+ },
+ }
+}
+
+// GetThresholdForEndpoint returns the effective threshold values for a given endpoint
+// Priority: endpoints > groups > defaults
+func (tc *ThresholdConfig) GetThresholdForEndpoint(endpoint string) ThresholdValues {
+ result := tc.Defaults
+
+ // Check group patterns (order matters - first match wins)
+ for pattern, groupThresholds := range tc.Groups {
+ if matchesPattern(endpoint, pattern) {
+ result = mergeThresholdValues(result, groupThresholds)
+ break
+ }
+ }
+
+ // Check exact endpoint matches
+ if endpointThresholds, exists := tc.Endpoints[endpoint]; exists {
+ result = mergeThresholdValues(result, endpointThresholds)
+ }
+
+ return result
+}
+
+// matchesPattern checks if an endpoint matches a pattern (supports wildcards and basic regex)
+func matchesPattern(endpoint, pattern string) bool {
+ // Convert wildcard pattern to regex
+ regexPattern := strings.ReplaceAll(pattern, "*", ".*")
+ regexPattern = "^" + regexPattern + "$"
+
+ matched, err := regexp.MatchString(regexPattern, endpoint)
+ if err != nil {
+ // If regex compilation fails, fall back to exact match
+ return endpoint == pattern
+ }
+
+ return matched
+}
+
+// mergeThresholdValues merges two threshold value sets, with the second taking precedence
+func mergeThresholdValues(base, override ThresholdValues) ThresholdValues {
+ result := base
+
+ if override.P50 != nil {
+ result.P50 = override.P50
+ }
+ if override.P90 != nil {
+ result.P90 = override.P90
+ }
+ if override.P95 != nil {
+ result.P95 = override.P95
+ }
+ if override.P99 != nil {
+ result.P99 = override.P99
+ }
+ if override.Avg != nil {
+ result.Avg = override.Avg
+ }
+ if override.Max != nil {
+ result.Max = override.Max
+ }
+ if override.ErrorRate != nil {
+ result.ErrorRate = override.ErrorRate
+ }
+ if override.RPS != nil {
+ result.RPS = override.RPS
+ }
+ if override.MinSamples != nil {
+ result.MinSamples = override.MinSamples
+ }
+
+ return result
+}
+
+// ValidateThresholds checks if metrics violate any thresholds
+func (tc *ThresholdConfig) ValidateThresholds(metrics *Metrics) []ThresholdBreach {
+ var breaches []ThresholdBreach
+
+ // Get minimum samples requirement
+ minSamples := tc.Options.MinSamples
+ if minSamples == 0 {
+ minSamples = 100 // Default minimum
+ }
+
+ // Check each endpoint metric
+ for metricName, metric := range metrics.Metrics {
+ // Skip non-endpoint metrics
+ if !isEndpointMetric(metricName) {
+ continue
+ }
+
+
+ endpoint := metricName
+ thresholds := tc.GetThresholdForEndpoint(endpoint)
+
+ // Check sample count first
+ sampleCount := int64(0)
+ if count, ok := metric.Values["count"].(int64); ok {
+ sampleCount = count
+ } else if count, ok := metric.Values["count"].(float64); ok {
+ sampleCount = int64(count)
+ }
+
+ // Skip if not enough samples
+ if sampleCount < int64(minSamples) {
+ continue
+ }
+
+ // Check duration-based thresholds
+ breaches = append(breaches, tc.checkDurationThresholds(endpoint, metric, thresholds, sampleCount)...)
+
+ // Check rate-based thresholds
+ breaches = append(breaches, tc.checkRateThresholds(endpoint, metric, thresholds, sampleCount)...)
+ }
+
+ return breaches
+}
+
+// isEndpointMetric checks if a metric name represents an endpoint metric
+func isEndpointMetric(metricName string) bool {
+ // Skip system metrics
+ systemMetrics := []string{
+ "http_req_duration", "http_reqs", "http_req_failed", "iterations",
+ "checks", "data_sent", "data_received", "vus", "vus_max",
+ }
+
+ for _, sys := range systemMetrics {
+ if strings.HasPrefix(metricName, sys) {
+ return false
+ }
+ }
+
+ return true
+}
+
+// checkDurationThresholds checks duration-based thresholds (p50, p90, p95, p99, avg, max)
+func (tc *ThresholdConfig) checkDurationThresholds(endpoint string, metric *Metric, thresholds ThresholdValues, sampleCount int64) []ThresholdBreach {
+ var breaches []ThresholdBreach
+
+ // Define duration threshold checks
+ checks := []struct {
+ key string
+ threshold *DurationThreshold
+ unit string
+ }{
+ {"p(50)", thresholds.P50, "ms"},
+ {"p(90)", thresholds.P90, "ms"},
+ {"p(95)", thresholds.P95, "ms"},
+ {"p(99)", thresholds.P99, "ms"},
+ {"avg", thresholds.Avg, "ms"},
+ {"max", thresholds.Max, "ms"},
+ }
+
+ for _, check := range checks {
+ if check.threshold == nil {
+ continue
+ }
+
+ value, ok := metric.Values[check.key].(float64)
+ if !ok {
+ continue
+ }
+
+ thresholdMs := float64(check.threshold.Value.Milliseconds())
+ tolerance := tc.Options.TolerancePercent
+ if check.threshold.Tolerance != nil {
+ tolerance = *check.threshold.Tolerance
+ }
+
+ // Apply tolerance
+ effectiveThreshold := thresholdMs * (1 + tolerance/100)
+
+ if value > effectiveThreshold {
+ severity := "error"
+ if value <= thresholdMs*(1+tolerance/100*1.5) {
+ severity = "warning"
+ }
+
+ breaches = append(breaches, ThresholdBreach{
+ Endpoint: endpoint,
+ Metric: check.key,
+ Value: value,
+ Threshold: thresholdMs,
+ Unit: check.unit,
+ Severity: severity,
+ SampleCount: sampleCount,
+ })
+ }
+ }
+
+ return breaches
+}
+
+// checkRateThresholds checks rate-based thresholds (error_rate, rps)
+func (tc *ThresholdConfig) checkRateThresholds(endpoint string, metric *Metric, thresholds ThresholdValues, sampleCount int64) []ThresholdBreach {
+ var breaches []ThresholdBreach
+
+ // Check error rate
+ if thresholds.ErrorRate != nil {
+ // Calculate error rate from the metric
+ errorRate := 0.0
+ if fails, ok := metric.Values["fails"].(int64); ok {
+ if total, ok := metric.Values["count"].(int64); ok && total > 0 {
+ errorRate = float64(fails) / float64(total)
+ }
+ }
+
+ threshold := thresholds.ErrorRate.Value
+ tolerance := tc.Options.TolerancePercent
+ if thresholds.ErrorRate.Tolerance != nil {
+ tolerance = *thresholds.ErrorRate.Tolerance
+ }
+
+ effectiveThreshold := threshold * (1 + tolerance/100)
+
+ if errorRate > effectiveThreshold {
+ severity := "error"
+ if errorRate <= threshold*(1+tolerance/100*1.5) {
+ severity = "warning"
+ }
+
+ breaches = append(breaches, ThresholdBreach{
+ Endpoint: endpoint,
+ Metric: "error_rate",
+ Value: errorRate * 100, // Convert to percentage for display
+ Threshold: threshold * 100,
+ Unit: "%",
+ Severity: severity,
+ SampleCount: sampleCount,
+ })
+ }
+ }
+
+ // Check RPS
+ if thresholds.RPS != nil {
+ if rate, ok := metric.Values["rate"].(float64); ok {
+ threshold := thresholds.RPS.Value
+ tolerance := tc.Options.TolerancePercent
+ if thresholds.RPS.Tolerance != nil {
+ tolerance = *thresholds.RPS.Tolerance
+ }
+
+ effectiveThreshold := threshold * (1 + tolerance/100)
+
+ if rate > effectiveThreshold {
+ severity := "error"
+ if rate <= threshold*(1+tolerance/100*1.5) {
+ severity = "warning"
+ }
+
+ breaches = append(breaches, ThresholdBreach{
+ Endpoint: endpoint,
+ Metric: "rps",
+ Value: rate,
+ Threshold: threshold,
+ Unit: "req/s",
+ Severity: severity,
+ SampleCount: sampleCount,
+ })
+ }
+ }
+ }
+
+ return breaches
+}
+
+// GetBreachSummary returns a summary of threshold breaches
+func (tc *ThresholdConfig) GetBreachSummary(breaches []ThresholdBreach) map[string]int {
+ summary := map[string]int{
+ "total": len(breaches),
+ "error": 0,
+ "warning": 0,
+ }
+
+ for _, v := range breaches {
+ summary[v.Severity]++
+ }
+
+ return summary
+}
+
+// LoadThresholdConfig loads threshold configuration from a YAML file
+func LoadThresholdConfig(filename string) (*ThresholdConfig, error) {
+ data, err := os.ReadFile(filename)
+ if err != nil {
+ return nil, fmt.Errorf("failed to read threshold config file: %w", err)
+ }
+
+ var config ThresholdConfig
+ err = yaml.Unmarshal(data, &config)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse threshold config YAML: %w", err)
+ }
+
+ // Set defaults if not provided
+ if config.Options.TolerancePercent == 0 {
+ config.Options.TolerancePercent = 10.0
+ }
+ if config.Options.MinSamples == 0 {
+ config.Options.MinSamples = 100
+ }
+
+ return &config, nil
+}
diff --git a/reporting/thresholds.yml b/reporting/thresholds.yml
new file mode 100644
index 00000000..b996edd0
--- /dev/null
+++ b/reporting/thresholds.yml
@@ -0,0 +1,59 @@
+# Venom Threshold Configuration
+# This file defines performance thresholds for API endpoints
+
+# Global options
+options:
+ tolerance_percent: 10 # Allow 10% headroom above thresholds
+ min_samples: 100 # Require at least 100 samples for reliable percentiles
+ soft_fail: false # Exit with error code on violations
+
+# Default thresholds applied to all endpoints
+defaults:
+ p95: 500ms # 95th percentile response time
+ p99: 1000ms # 99th percentile response time
+ avg: 200ms # Average response time
+ error_rate: 0.01 # 1% error rate maximum
+
+# Group-based thresholds (supports wildcards)
+groups:
+ "auth/*": # All authentication endpoints
+ p95: 350ms
+ avg: 150ms
+ error_rate: 0.005 # 0.5% error rate for auth endpoints
+
+ "catalog/*": # All catalog endpoints
+ p95: 450ms
+ avg: 180ms
+
+ "api/v1/*": # All v1 API endpoints
+ p95: 400ms
+ avg: 160ms
+
+# Endpoint-specific thresholds (highest priority)
+endpoints:
+ "GET /users": # User listing endpoint
+ p95: 300ms
+ avg: 150ms
+ error_rate: 0.001 # Very low error rate for user data
+
+ "POST /orders": # Order creation endpoint
+ p95: 800ms # Allow longer for order processing
+ avg: 400ms
+ error_rate: 0.002
+
+ "GET /health": # Health check endpoint
+ p95: 50ms # Health checks should be very fast
+ avg: 20ms
+ error_rate: 0.0 # No errors allowed for health checks
+
+ "POST /auth/login": # Login endpoint
+ p95: 200ms
+ avg: 100ms
+ error_rate: 0.01 # Higher error rate allowed for auth failures
+
+# Example with custom tolerance
+ "GET /reports": # Report generation endpoint
+ p95: 2000ms # Reports can take longer
+ avg: 800ms
+ error_rate: 0.02 # 2% error rate for complex operations
+ tolerance_percent: 20 # Allow 20% headroom for this endpoint
diff --git a/reporting/thresholds_test.go b/reporting/thresholds_test.go
new file mode 100644
index 00000000..07b33635
--- /dev/null
+++ b/reporting/thresholds_test.go
@@ -0,0 +1,191 @@
+package reporting
+
+import (
+ "testing"
+ "time"
+)
+
+func TestDefaultThresholdConfig(t *testing.T) {
+ config := DefaultThresholdConfig()
+
+ if config.Defaults.P95 == nil {
+ t.Error("Default P95 threshold should be set")
+ }
+
+ if config.Defaults.P95.Value != 500*time.Millisecond {
+ t.Errorf("Expected default P95 to be 500ms, got %v", config.Defaults.P95.Value)
+ }
+
+ if config.Options.TolerancePercent != 10.0 {
+ t.Errorf("Expected default tolerance to be 10%%, got %v", config.Options.TolerancePercent)
+ }
+}
+
+func TestGetThresholdForEndpoint(t *testing.T) {
+ config := DefaultThresholdConfig()
+
+ // Test exact endpoint match
+ thresholds := config.GetThresholdForEndpoint("GET /users")
+ if thresholds.P95 == nil || thresholds.P95.Value != 300*time.Millisecond {
+ t.Error("GET /users should have P95 threshold of 300ms")
+ }
+
+ // Test group pattern match
+ thresholds = config.GetThresholdForEndpoint("auth/login")
+ if thresholds.P95 == nil || thresholds.P95.Value != 350*time.Millisecond {
+ t.Error("auth/* endpoints should have P95 threshold of 350ms")
+ }
+
+ // Test default fallback
+ thresholds = config.GetThresholdForEndpoint("GET /unknown")
+ if thresholds.P95 == nil || thresholds.P95.Value != 500*time.Millisecond {
+ t.Error("Unknown endpoints should use default P95 threshold of 500ms")
+ }
+}
+
+func TestMatchesPattern(t *testing.T) {
+ tests := []struct {
+ endpoint string
+ pattern string
+ expected bool
+ }{
+ {"auth/login", "auth/*", true},
+ {"auth/logout", "auth/*", true},
+ {"catalog/products", "catalog/*", true},
+ {"GET /users/profile", "auth/*", false},
+ {"GET /users", "GET /users", true},
+ {"POST /users", "GET /users", false},
+ }
+
+ for _, test := range tests {
+ result := matchesPattern(test.endpoint, test.pattern)
+ if result != test.expected {
+ t.Errorf("matchesPattern(%q, %q) = %v, expected %v",
+ test.endpoint, test.pattern, result, test.expected)
+ }
+ }
+}
+
+func TestValidateThresholds(t *testing.T) {
+ config := DefaultThresholdConfig()
+
+ // Create test metrics with a breach
+ metrics := &Metrics{
+ Metrics: map[string]*Metric{
+ "GET /users": {
+ Type: "trend",
+ Values: map[string]interface{}{
+ "p(95)": 400.0, // Exceeds 300ms threshold
+ "avg": 120.0, // Within 150ms threshold
+ "count": int64(150), // Above min samples
+ },
+ },
+ "GET /slow": {
+ Type: "trend",
+ Values: map[string]interface{}{
+ "p(95)": 600.0, // Exceeds default 500ms threshold
+ "count": int64(50), // Below min samples - should be skipped
+ },
+ },
+ },
+ }
+
+ breaches := config.ValidateThresholds(metrics)
+
+ if len(breaches) != 1 {
+ t.Errorf("Expected 1 breach, got %d", len(breaches))
+ }
+
+ if len(breaches) > 0 {
+ v := breaches[0]
+ if v.Endpoint != "GET /users" {
+ t.Errorf("Expected breach for GET /users, got %s", v.Endpoint)
+ }
+ if v.Metric != "p(95)" {
+ t.Errorf("Expected p(95) breach, got %s", v.Metric)
+ }
+ if v.Value != 400.0 {
+ t.Errorf("Expected breach value 400.0, got %v", v.Value)
+ }
+ }
+}
+
+func TestMergeThresholdValues(t *testing.T) {
+ base := ThresholdValues{
+ P95: &DurationThreshold{Value: 500 * time.Millisecond},
+ Avg: &DurationThreshold{Value: 200 * time.Millisecond},
+ }
+
+ override := ThresholdValues{
+ P95: &DurationThreshold{Value: 300 * time.Millisecond},
+ P99: &DurationThreshold{Value: 1000 * time.Millisecond},
+ }
+
+ result := mergeThresholdValues(base, override)
+
+ // P95 should be overridden
+ if result.P95.Value != 300*time.Millisecond {
+ t.Errorf("Expected P95 to be overridden to 300ms, got %v", result.P95.Value)
+ }
+
+ // Avg should remain from base
+ if result.Avg.Value != 200*time.Millisecond {
+ t.Errorf("Expected Avg to remain 200ms, got %v", result.Avg.Value)
+ }
+
+ // P99 should be added from override
+ if result.P99.Value != 1000*time.Millisecond {
+ t.Errorf("Expected P99 to be added as 1000ms, got %v", result.P99.Value)
+ }
+}
+
+func TestIsEndpointMetric(t *testing.T) {
+ tests := []struct {
+ metricName string
+ expected bool
+ }{
+ {"GET /users", true},
+ {"POST /orders", true},
+ {"http_req_duration", false},
+ {"http_reqs", false},
+ {"http_req_failed", false},
+ {"iterations", false},
+ {"checks", false},
+ {"data_sent", false},
+ {"data_received", false},
+ {"vus", false},
+ {"vus_max", false},
+ }
+
+ for _, test := range tests {
+ result := isEndpointMetric(test.metricName)
+ if result != test.expected {
+ t.Errorf("isEndpointMetric(%q) = %v, expected %v",
+ test.metricName, result, test.expected)
+ }
+ }
+}
+
+func TestGetBreachSummary(t *testing.T) {
+ config := DefaultThresholdConfig()
+
+ breaches := []ThresholdBreach{
+ {Severity: "error"},
+ {Severity: "error"},
+ {Severity: "warning"},
+ {Severity: "warning"},
+ {Severity: "warning"},
+ }
+
+ summary := config.GetBreachSummary(breaches)
+
+ if summary["total"] != 5 {
+ t.Errorf("Expected total breaches 5, got %d", summary["total"])
+ }
+ if summary["error"] != 2 {
+ t.Errorf("Expected error breaches 2, got %d", summary["error"])
+ }
+ if summary["warning"] != 3 {
+ t.Errorf("Expected warning breaches 3, got %d", summary["warning"])
+ }
+}
diff --git a/venom.go b/venom.go
index 4d48dbdf..af97191c 100644
--- a/venom.go
+++ b/venom.go
@@ -75,6 +75,14 @@ type Venom struct {
OpenApiReport bool
FailureLinkHeader string
FailureLinkTemplate string
+ MetricsEnabled bool
+ MetricsOutput string
+ metricsCollector reporting.MetricsCollector
+}
+
+// SetMetricsCollector sets the metrics collector for the Venom instance
+func (v *Venom) SetMetricsCollector(collector reporting.MetricsCollector) {
+ v.metricsCollector = collector
}
var trace = color.New(color.Attribute(90)).SprintFunc()