Feature Request: SetUserValue key changed to interface{}

[pjebs]

Currently SetUserValue accepts only a string for a key.
This is a limitation.

It would be great if the key accepted an interface{} similar to context.Context: https://pkg.go.dev/context#WithValue

The rationale for the (arguably backward compatible change) is that if it accepts interface{}, I can make the key into an unexported internal type.

That way, outside packages can't tamper with my user value.

In the fiber framework, the fiber context (which gives access to fasthttp.uservalue) is passed down middlewares. Some of these middleware are external packages I have no control over.

I need to protect some of my user values so they don't get tampered with. If the type of key is an unexported internal type, they can't modify it.

This approach is heavily used by context.Context.

type internalKey string

ctx.SetUserValue( internalKey("my key"), 22)

[erikdubbelboer]

I'm not sure what to think of this. It will cause extra allocations. But I guess anyone who cares about that wouldn't be using SetUserValue anyways.

I don't have time to add support for this at the moment, so a pull request would be very nice.

[pjebs]

In the context.WithValue documentation it states:

The provided key must be comparable and should not be of type string or any other built-in type to avoid collisions between packages using context. Users of WithValue should define their own types for keys. To avoid allocating when assigning to an interface{}, context keys often have concrete type struct{}. Alternatively, exported context key variables' static type should be a pointer or interface.

With regards to your concern about extra allocations, can you help me understand what they are saying?

Then I will issue a PR.

[erikdubbelboer]

They are saying that with context if you do:

type internalKey struct{}

ctx.SetUserValue( internalKey{}, 22)

it won't allocate because an empty struct has no size so it fits within the interface{} without having to allocate extra memory.

While doing:

type internalKey string

ctx.SetUserValue( internalKey("my key"), 22)

would cause an extra allocation since string is too big to fit into the interface{}. So an extra string will get allocated on the heap and the interface{} will point to that.

[pjebs]

@erikdubbelboer Thanks for explaining

[pjebs]

@erikdubbelboer Any idea when new version will be tagged?

[erikdubbelboer]

I'll tag one on Monday.