feat: add metrics system, move webhook feature to dedicated module (#372)

pkg/gotenberg/flags.go

@@ -25,6 +25,17 @@ func (f *ParsedFlags) MustString(name string) string {
 	return val
 }
 
+// MustDeprecatedString returns the string value of a deprecated flag if it was
+// explicitly set or the string value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustString(deprecated)
+	}
+
+	return f.MustString(newName)
+}
+
 // MustStringSlice returns the string slice value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustStringSlice(name string) []string {
@@ -36,6 +47,17 @@ func (f *ParsedFlags) MustStringSlice(name string) []string {
 	return val
 }
 
+// MustDeprecatedStringSlice returns the string slice value of a deprecated
+// flag if it was explicitly set or the string slice value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedStringSlice(deprecated string, newName string) []string {
+	if f.Changed(deprecated) {
+		return f.MustStringSlice(deprecated)
+	}
+
+	return f.MustStringSlice(newName)
+}
+
 // MustBool returns the boolean value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustBool(name string) bool {
@@ -47,6 +69,17 @@ func (f *ParsedFlags) MustBool(name string) bool {
 	return val
 }
 
+// MustDeprecatedBool returns the boolean value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedBool(deprecated string, newName string) bool {
+	if f.Changed(deprecated) {
+		return f.MustBool(deprecated)
+	}
+
+	return f.MustBool(newName)
+}
+
 // MustInt returns the int value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustInt(name string) int {
@@ -58,6 +91,17 @@ func (f *ParsedFlags) MustInt(name string) int {
 	return val
 }
 
+// MustDeprecatedInt returns the int value of a deprecated flag if it was
+// explicitly set or the int value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedInt(deprecated string, newName string) int {
+	if f.Changed(deprecated) {
+		return f.MustInt(deprecated)
+	}
+
+	return f.MustInt(newName)
+}
+
 // MustFloat64 returns the float value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustFloat64(name string) float64 {
@@ -69,6 +113,17 @@ func (f *ParsedFlags) MustFloat64(name string) float64 {
 	return val
 }
 
+// MustDeprecatedFloat64 returns the float value of a deprecated flag if it was
+// explicitly set or the float value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedFloat64(deprecated string, newName string) float64 {
+	if f.Changed(deprecated) {
+		return f.MustFloat64(deprecated)
+	}
+
+	return f.MustFloat64(newName)
+}
+
 // MustDuration returns the time.Duration value of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustDuration(name string) time.Duration {
@@ -80,6 +135,17 @@ func (f *ParsedFlags) MustDuration(name string) time.Duration {
 	return val
 }
 
+// MustDeprecatedDuration returns the time.Duration value of a deprecated flag
+// if it was explicitly set or the time.Duration value of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedDuration(deprecated string, newName string) time.Duration {
+	if f.Changed(deprecated) {
+		return f.MustDuration(deprecated)
+	}
+
+	return f.MustDuration(newName)
+}
+
 // MustHumanReadableBytesString returns the human-readable bytes string of a
 // flag given by name.
 // It panics if an error occurs.
@@ -97,6 +163,18 @@ func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
 	return val
 }
 
+// MustDeprecatedHumanReadableBytesString returns the human-readable bytes
+// string of a deprecated flag if it was explicitly set or the human-readable
+// bytes string of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedHumanReadableBytesString(deprecated string, newName string) string {
+	if f.Changed(deprecated) {
+		return f.MustHumanReadableBytesString(deprecated)
+	}
+
+	return f.MustHumanReadableBytesString(newName)
+}
+
 // MustRegexp returns the regular expression of a flag given by name.
 // It panics if an error occurs.
 func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {
@@ -107,3 +185,14 @@ func (f *ParsedFlags) MustRegexp(name string) *regexp.Regexp {
 
 	return regexp.MustCompile(val)
 }
+
+// MustDeprecatedRegexp returns the regular expression of a deprecated flag if
+// it was explicitly set or the regular expression of the new flag.
+// It panics if an error occurs.
+func (f *ParsedFlags) MustDeprecatedRegexp(deprecated string, newName string) *regexp.Regexp {
+	if f.Changed(deprecated) {
+		return f.MustRegexp(deprecated)
+	}
+
+	return f.MustRegexp(newName)
+}

pkg/gotenberg/flags_test.go

@@ -1,6 +1,8 @@
 package gotenberg
 
 import (
+	"reflect"
+	"regexp"
 	"testing"
 	"time"
 
@@ -52,6 +54,42 @@ func TestParsedFlags_MustString(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedString(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: "foo",
+		},
+		{
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: "bar",
+		},
+		{
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: "foo",
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.String("foo", "", "")
+		fs.String("bar", "", "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedString("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustStringSlice(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.StringSlice("foo", make([]string, 0), "")
@@ -97,6 +135,42 @@ func TestParsedFlags_MustStringSlice(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedStringSlice(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue []string
+	}{
+		{
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: []string{"foo"},
+		},
+		{
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: []string{"bar"},
+		},
+		{
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: []string{"foo"},
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.StringSlice("foo", make([]string, 0), "")
+		fs.StringSlice("bar", make([]string, 0), "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedStringSlice("foo", "bar")
+		if !reflect.DeepEqual(actual, tc.expectValue) {
+			t.Errorf("test %d: expected %+v but got %+v", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustBool(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Bool("foo", false, "")
@@ -142,6 +216,42 @@ func TestParsedFlags_MustBool(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedBool(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue bool
+	}{
+		{
+			rawFlags:    []string{"--foo=true"},
+			expectValue: true,
+		},
+		{
+			rawFlags:    []string{"--bar=false"},
+			expectValue: false,
+		},
+		{
+			rawFlags:    []string{"--foo=true", "--bar=false"},
+			expectValue: true,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Bool("foo", false, "")
+		fs.Bool("bar", true, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedBool("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected %v but got %v", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustInt(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Int("foo", 0, "")
@@ -187,6 +297,42 @@ func TestParsedFlags_MustInt(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedInt(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue int
+	}{
+		{
+			rawFlags:    []string{"--foo=1"},
+			expectValue: 1,
+		},
+		{
+			rawFlags:    []string{"--bar=2"},
+			expectValue: 2,
+		},
+		{
+			rawFlags:    []string{"--foo=1", "--bar=2"},
+			expectValue: 1,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Int("foo", 0, "")
+		fs.Int("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedInt("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected %d but got %d", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustFloat64(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Float64("foo", 1.0, "")
@@ -232,6 +378,42 @@ func TestParsedFlags_MustFloat64(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedFloat64(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue float64
+	}{
+		{
+			rawFlags:    []string{"--foo=1.0"},
+			expectValue: 1.0,
+		},
+		{
+			rawFlags:    []string{"--bar=2.0"},
+			expectValue: 2.0,
+		},
+		{
+			rawFlags:    []string{"--foo=1.0", "--bar=2.0"},
+			expectValue: 1.0,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Float64("foo", 0, "")
+		fs.Float64("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedFloat64("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected %f but got %f", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustDuration(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.Duration("foo", time.Duration(1)*time.Second, "")
@@ -277,6 +459,42 @@ func TestParsedFlags_MustDuration(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedDuration(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue time.Duration
+	}{
+		{
+			rawFlags:    []string{"--foo=1s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+		{
+			rawFlags:    []string{"--bar=2s"},
+			expectValue: time.Duration(2) * time.Second,
+		},
+		{
+			rawFlags:    []string{"--foo=1s", "--bar=2s"},
+			expectValue: time.Duration(1) * time.Second,
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.Duration("foo", 0, "")
+		fs.Duration("bar", 0, "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedDuration("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.String("foo", "1MB", "")
@@ -327,6 +545,42 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 	}
 }
 
+func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue string
+	}{
+		{
+			rawFlags:    []string{"--foo=1MB"},
+			expectValue: "1MB",
+		},
+		{
+			rawFlags:    []string{"--bar=2MB"},
+			expectValue: "2MB",
+		},
+		{
+			rawFlags:    []string{"--foo=1MB", "--bar=2MB"},
+			expectValue: "1MB",
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.String("foo", "", "")
+		fs.String("bar", "", "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedHumanReadableBytesString("foo", "bar")
+		if actual != tc.expectValue {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue, actual)
+		}
+	}
+}
+
 func TestParsedFlags_MustRegexp(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.String("foo", "", "")
@@ -376,3 +630,39 @@ func TestParsedFlags_MustRegexp(t *testing.T) {
 		}()
 	}
 }
+
+func TestParsedFlags_MustDeprecatedRegexp(t *testing.T) {
+	for i, tc := range []struct {
+		rawFlags    []string
+		expectValue *regexp.Regexp
+	}{
+		{
+			rawFlags:    []string{"--foo=foo"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+		{
+			rawFlags:    []string{"--bar=bar"},
+			expectValue: regexp.MustCompile("bar"),
+		},
+		{
+			rawFlags:    []string{"--foo=foo", "--bar=bar"},
+			expectValue: regexp.MustCompile("foo"),
+		},
+	} {
+		fs := flag.NewFlagSet("tests", flag.ContinueOnError)
+		fs.String("foo", "", "")
+		fs.String("bar", "", "")
+
+		parsedFlags := ParsedFlags{FlagSet: fs}
+
+		err := parsedFlags.Parse(tc.rawFlags)
+		if err != nil {
+			t.Fatalf("test %d: expected no error but got: %v", i, err)
+		}
+
+		actual := parsedFlags.MustDeprecatedRegexp("foo", "bar")
+		if actual.String() != tc.expectValue.String() {
+			t.Errorf("test %d: expected '%s' but got '%s'", i, tc.expectValue.String(), actual.String())
+		}
+	}
+}

pkg/gotenberg/metrics.go

@@ -0,0 +1,26 @@
+package gotenberg
+
+// Metric represents a unitary metric.
+type Metric struct {
+	// Name is the unique identifier.
+	// Required.
+	Name string
+
+	// Description describes the metric.
+	// Optional.
+	Description string
+
+	// Read returns the current value.
+	// Required.
+	Read func() float64
+}
+
+// MetricsProvider is a module interface which provides a list of Metric.
+//
+//	func (m *YourModule) Provision(ctx *gotenberg.Context) error {
+//		provider, _ := ctx.Module(new(gotenberg.MetricsProvider))
+//		metrics, _  := provider.(gotenberg.MetricsProvider).Metrics()
+//	}
+type MetricsProvider interface {
+	Metrics() ([]Metric, error)
+}