Golang microservice middleware allow any type but be strict on endpoint

New to golang but what I'm trying to do is make my logging middleware generic e.g. allow any type and then call the method for the next layer.

So below us the loggingmiddleware package, where I want to be able to accept any type and print it out.

package loggingmiddleware

import (
	"context"
	"time"

	gokitlogger "github.com/go-kit/kit/log"
)

type layer interface {
	Run(context.Context, interface{}) (interface{}, error)
}

type LoggingMiddleware struct {
	Logger gokitlogger.Logger
	Layer  layer
}

func (mw LoggingMiddleware) Run(ctx context.Context, i interface{}) (output interface{}, err error) {

	defer func(begin time.Time) {

		mw.Logger.Log(
			"method", "name of method",
			"input", i,
			"output", output,
			"err", err,
			"took", time.Since(begin),
		)

	}(time.Now())

	output, err = mw.Layer.Run(ctx, i)
	return

}

However I want to be strict when calling the next method, if it needs to be string I want to set the type to be string rather than interface{}

In my example I want to make sure only a float64 type will be used as an argument

type mathServiceInterface interface {
	Run(context.Context, float64) (float64, error)
}

type mathService struct{}

func (mathService) Run(_ context.Context, f float64) (float64, error) {
	return f * f, nil
}

However with my current implementation I'm getting this error...

# github.com/jakelacey2012/blankit/blankit-ms/sqaure

./main.go:92: cannot use ms (type mathServiceInterface) as type loggingmiddleware.layer in field value:
        mathServiceInterface does not implement loggingmiddleware.layer (wrong type for Run method)
                have Run(context.Context, float64) (float64, error)
                want Run(context.Context, interface {}) (interface {}, error)

./main.go:92: cannot use loggingmiddleware.LoggingMiddleware literal (type loggingmiddleware.LoggingMiddleware) as type mathServiceInterface in assignment:
        loggingmiddleware.LoggingMiddleware does not implement mathServiceInterface (wrong type for Run method)
                have Run(context.Context, interface {}) (interface {}, error)
                want Run(context.Context, float64) (float64, error)

I understand the error, however I don't know whether my implementation is over complicating things because I don't know go.

I hope what I'm saying makes sense, I was unsure what to title this as so please feel free to edit it.

Also if you need more code to better explain please do let me know.

What's going to be calling these? At some point there is an actual consumer, and that consumer will (presumably, based on your code) be using an interface (either layer or an identical interface). If there's middleware, that interface will necessarily be as generic as the middleware - i.e., taking a interface{} as a parameter to Run. So making something downstream more specific (besides not compiling as you've seen) doesn't make any sense: the actual consumer won't see the more-specific interface, it will see Run(Context,interface{}) (interface{},error).

The error message says it all, for a type to implement an interface its methods must exactly match the methods the interface defines.

Sadly, this means that your system won't work as designed. You will either need to use interface{} and assert to the actual type at the end point, or you will need a separate interface (and logger function) for each type.