Graphite: Decouple from core Grafana (#110294)

* Add lint rules

* Backend decoupling

- Add standalone files
- Add graphite query type
- Add logger to Service
- Create logger in the ProvideService method
- Use a pointer for the HTTP client provider
- Update logger usage everywhere
- Update tracer type
- Replace simplejson with json
- Add dummy CallResource and CheckHealth methods
- Update tests

* Update ConfigEditor imports

* Update types imports

* Update datasource

- Switch to using semver package
- Update imports

* Update store imports

* Update helper imports and notification creation

* Update context import

* Update version numbers and logic

* Copy array_move from core

* Test updates

* Add required files and update plugin.json

* Update core references and packages

* Remove commented code

* Update wire

* Lint

* Fix import

* Copy null type

* More lint

* Update snapshot

* Add tests

* Review

* Fix packages

pkg/tsdb/graphite/null_float.go

@@ -0,0 +1,143 @@
+// Copied from Grafana core https://github.com/grafana/grafana/blob/main/pkg/components/null/float.go
+// Graphite DataPoints utilise the Float type here https://github.com/grafana/grafana/blob/main/pkg/tsdb/graphite/types.go#L10
+package graphite
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+)
+
+const (
+	nullString = "null"
+)
+
+// Float is a nullable float64.
+// It does not consider zero values to be null.
+// It will decode to null, not zero, if null.
+type Float struct {
+	sql.NullFloat64
+}
+
+// NewFloat creates a new Float
+func NewFloat(f float64, valid bool) Float {
+	return Float{
+		NullFloat64: sql.NullFloat64{
+			Float64: f,
+			Valid:   valid,
+		},
+	}
+}
+
+// FloatFrom creates a new Float that will always be valid.
+func FloatFrom(f float64) Float {
+	return NewFloat(f, true)
+}
+
+// FloatFromPtr creates a new Float that be null if f is nil.
+func FloatFromPtr(f *float64) Float {
+	if f == nil {
+		return NewFloat(0, false)
+	}
+	return NewFloat(*f, true)
+}
+
+// FloatFromString creates a new Float from string f.
+// If the string is equal to the value of nullString then the Float will be null.
+// An empty string f will return an error.
+func FloatFromString(f string, nullString string) (Float, error) {
+	if f == nullString {
+		return FloatFromPtr(nil), nil
+	}
+	fV, err := strconv.ParseFloat(f, 64)
+	if err != nil {
+		return Float{}, err
+	}
+	return FloatFrom(fV), nil
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+// It supports number and null input.
+// 0 will not be considered a null Float.
+// It also supports unmarshaling a sql.NullFloat64.
+func (f *Float) UnmarshalJSON(data []byte) error {
+	var err error
+	var v any
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		f.Float64 = x
+	case map[string]any:
+		err = json.Unmarshal(data, &f.NullFloat64)
+	case nil:
+		f.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type null.Float", reflect.TypeOf(v).Name())
+	}
+	f.Valid = err == nil
+	return err
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+// It will unmarshal to a null Float if the input is a blank or not an integer.
+// It will return an error if the input is not an integer, blank, or "null".
+func (f *Float) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == nullString {
+		f.Valid = false
+		return nil
+	}
+	var err error
+	f.Float64, err = strconv.ParseFloat(string(text), 64)
+	f.Valid = err == nil
+	return err
+}
+
+// MarshalJSON implements json.Marshaler.
+// It will encode null if this Float is null, NaN, of Inf.
+func (f Float) MarshalJSON() ([]byte, error) {
+	if !f.Valid || math.IsNaN(f.Float64) || math.IsInf(f.Float64, 0) {
+		return []byte(nullString), nil
+	}
+	return []byte(strconv.FormatFloat(f.Float64, 'f', -1, 64)), nil
+}
+
+// MarshalText implements encoding.TextMarshaler.
+// It will encode a blank string if this Float is null.
+func (f Float) MarshalText() ([]byte, error) {
+	if !f.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatFloat(f.Float64, 'f', -1, 64)), nil
+}
+
+// MarshalText implements encoding.TextMarshaler.
+// It will encode a blank string if this Float is null.
+func (f Float) String() string {
+	if !f.Valid {
+		return nullString
+	}
+
+	return fmt.Sprintf("%1.3f", f.Float64)
+}
+
+// FullString returns float as string in full precision
+func (f Float) FullString() string {
+	if !f.Valid {
+		return nullString
+	}
+
+	return fmt.Sprintf("%f", f.Float64)
+}
+
+// IsZero returns true for invalid Floats, for future omitempty support (Go 1.4?)
+// A non-null Float with a 0 value will not be considered zero.
+func (f Float) IsZero() bool {
+	return !f.Valid
+}