Type-safe conversion for line-protocol Addfield

[arukiidou]

Use Case

• I want asserure that AddField() without panicking.
• avoiding reflect.
• Please show me the error while I am editing in VSCode.

Expected behavior

• use unsupported types, then compile error.

func example() {
    p := NewPoint("measurement", map[string]string{}, map[string]interface{}{"measurement": "air"}, time.Now())
        // unsupported type.
    p.AddFieldFromValue("✅ Compile error.", cmplx.Inf())
        // supported type.
    p.AddFieldFromValue("✅ This is safe.", NewValueFromInt(255))
}

Actual behavior

• use unsupported types, then panic.

func example() {
    p := NewPoint("measurement", map[string]string{}, map[string]interface{}{"measurement": "air"}, time.Now())
        // unsupported type.
    p.AddField("❌ Will panic.", cmplx.Inf())
        // supported type.
    p.AddField("❓This is OK, but really?", 255)
}

Additional info

• 42

• Which API do you prefer(NewValueFrom VS NewFieldFrom)?
  • NewValueFrom wins.

NewValueFrom

func (m *Point) AddFieldFromValue(k string, v lineprotocol.Value) *Point {}
func NewValueFromInt[I Integer](v I) lineprotocol.Value {}

(Retracted)NewFieldFrom

func (m *Point) AddFieldRaw(k string, v Field) *Point {}
func NewFieldFromInt[I Integer](v I) Field {}

Why not line-protocol?

• line-protocol v2 dont support generics yet.

[bednar]

Hi @arukiidou,

Thank you for raising the issue and submitting your PR. I have a preference for Variant A.

Best regards

[arukiidou]

benchmarking

✅ This is not only type safe, lower memory allocation and performance improvement.

go test -bench . -benchmem
cpu: Intel(R) Core(TM) i5-10400 CPU @ 2.90GHz
// p.AddField("float64", f)
BenchmarkAddField-12                     3476425               344.5 ns/op           152 B/op          9 allocs/op
// p.AddFieldFromValue("float64", NewValueFromFloat(f))
BenchmarkNewValueFromTyped-12            9434280               121.2 ns/op            48 B/op          2 allocs/op
// p.AddFieldFromValue("float64", NewValueFromNative(f))
BenchmarkNewValueFromNative-12           4411726               269.3 ns/op           112 B/op          7 allocs/op

func BenchmarkAddField(b *testing.B) {
    // cpu: Intel(R) Core(TM) i5-10400 CPU @ 2.90GHz
    // BenchmarkAddPoint-12                  3410827           345.9 ns/op       152 B/op          9 allocs/op
    // BenchmarkNewValueFromTyped-12         9870652           122.6 ns/op        48 B/op          2 allocs/op
    // BenchmarkNewValueFromNative-12        4241845           282.0 ns/op       112 B/op          7 allocs/op
    p := NewPoint(
        "bench",
        map[string]string{
            "id":        "10ad=",
            "ven=dor":   "AWS",
            `host"name`: `ho\st "a"`,
            `x\" x`:     "a b",
        },
        map[string]interface{}{},
        time.Unix(60, 70))

    f := float64(80.1234567)
    ints := int64(-1234567890)
    u := uint64(12345677890)
    s := string(`six, "seven", eight`)
    bt := []byte(`six=seven\, eight`)
    bl := bool(false)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        p.AddField("float64", f)
        p.AddField("int64", ints)
        p.AddField("uint64", u)
        p.AddField("string", s)
        p.AddField("bytes", bt)
        p.AddField("bool", bl)
    }
}

func BenchmarkNewValueFromTyped(b *testing.B) {
    // BenchmarkNewValueFromTyped-12         9870652           122.6 ns/op        48 B/op          2 allocs/op
    // BenchmarkNewValueFromNative-12        4241845           282.0 ns/op       112 B/op          7 allocs/op
    p := NewPoint(
        "bench",
        map[string]string{
            "id":        "10ad=",
            "ven=dor":   "AWS",
            `host"name`: `ho\st "a"`,
            `x\" x`:     "a b",
        },
        map[string]interface{}{},
        time.Unix(60, 70))

    f := float64(80.1234567)
    ints := int64(-1234567890)
    u := uint64(12345677890)
    s := string(`six, "seven", eight`)
    bt := []byte(`six=seven\, eight`)
    bl := bool(false)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        p.AddFieldFromValue("float64", NewValueFromFloat(f))
        p.AddFieldFromValue("int64", NewValueFromInt(ints))
        p.AddFieldFromValue("uint64", NewValueFromUInt(u))
        p.AddFieldFromValue("string", NewValueFromString(s))
        p.AddFieldFromValue("bytes", NewValueFromString(bt))
        p.AddFieldFromValue("bool", NewValueFromBoolean(bl))
    }
}

func BenchmarkNewValueFromNative(b *testing.B) {
    // BenchmarkNewValueFromNative-12        4241845           282.0 ns/op       112 B/op          7 allocs/op
    p := NewPoint(
        "bench",
        map[string]string{
            "id":        "10ad=",
            "ven=dor":   "AWS",
            `host"name`: `ho\st "a"`,
            `x\" x`:     "a b",
        },
        map[string]interface{}{},
        time.Unix(60, 70))

    f := float64(80.1234567)
    ints := int64(-1234567890)
    u := uint64(12345677890)
    s := string(`six, "seven", eight`)
    bt := []byte(`six=seven\, eight`)
    bl := bool(false)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        p.AddFieldFromValue("float64", NewValueFromNative(f))
        p.AddFieldFromValue("int64", NewValueFromNative(ints))
        p.AddFieldFromValue("uint64", NewValueFromNative(u))
        p.AddFieldFromValue("string", NewValueFromNative(s))
        p.AddFieldFromValue("bytes", NewValueFromNative(bt))
        p.AddFieldFromValue("bool", NewValueFromNative(bl))
    }
}

AddField

NewValueFrom-Typed

NewValueFrom-Native