+
+
package feast
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "os"
+ "strings"
+
+ "github.com/apache/arrow/go/v8/arrow/memory"
+ "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+
+ "github.com/feast-dev/feast/go/internal/feast/model"
+ "github.com/feast-dev/feast/go/internal/feast/onlineserving"
+ "github.com/feast-dev/feast/go/internal/feast/onlinestore"
+ "github.com/feast-dev/feast/go/internal/feast/registry"
+ "github.com/feast-dev/feast/go/internal/feast/transformation"
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ prototypes "github.com/feast-dev/feast/go/protos/feast/types"
+)
+
+type FeatureStoreInterface interface {
+ GetOnlineFeatures(
+ ctx context.Context,
+ featureRefs []string,
+ featureService *model.FeatureService,
+ joinKeyToEntityValues map[string]*prototypes.RepeatedValue,
+ requestData map[string]*prototypes.RepeatedValue,
+ fullFeatureNames bool) ([]*onlineserving.FeatureVector, error)
+}
+type FeatureStore struct {
+ config *registry.RepoConfig
+ registry *registry.Registry
+ onlineStore onlinestore.OnlineStore
+ transformationCallback transformation.TransformationCallback
+ transformationService *transformation.GrpcTransformationService
+}
+
+// A Features struct specifies a list of features to be retrieved from the online store. These features
+// can be specified either as a list of string feature references or as a feature service. String
+// feature references must have format "feature_view:feature", e.g. "customer_fv:daily_transactions".
+type Features struct {
+ FeaturesRefs []string
+ FeatureService *model.FeatureService
+}
+
+func (fs *FeatureStore) Registry() *registry.Registry {
+ return fs.registry
+}
+
+func (fs *FeatureStore) GetRepoConfig() *registry.RepoConfig {
+ return fs.config
+}
+
+// NewFeatureStore constructs a feature store fat client using the
+// repo config (contents of feature_store.yaml converted to JSON map).
+func NewFeatureStore(config *registry.RepoConfig, callback transformation.TransformationCallback) (*FeatureStore, error) {
+ onlineStore, err := onlinestore.NewOnlineStore(config)
+ if err != nil {
+ return nil, err
+ }
+ registryConfig, err := config.GetRegistryConfig()
+ if err != nil {
+ return nil, err
+ }
+ registry, err := registry.NewRegistry(registryConfig, config.RepoPath, config.Project)
+ if err != nil {
+ return nil, err
+ }
+ err = registry.InitializeRegistry()
+ if err != nil {
+ return nil, err
+ }
+ sanitizedProjectName := strings.Replace(config.Project, "_", "-", -1)
+ productName := os.Getenv("PRODUCT")
+ endpoint := fmt.Sprintf("%s-transformations.%s.svc.cluster.local:80", sanitizedProjectName, productName)
+ transformationService, _ := transformation.NewGrpcTransformationService(config, endpoint)
+
+ return &FeatureStore{
+ config: config,
+ registry: registry,
+ onlineStore: onlineStore,
+ transformationCallback: callback,
+ transformationService: transformationService,
+ }, nil
+}
+
+// TODO: Review all functions that use ODFV and Request FV since these have not been tested
+// ToDo: Split GetOnlineFeatures interface into two: GetOnlinFeaturesByFeatureService and GetOnlineFeaturesByFeatureRefs
+func (fs *FeatureStore) GetOnlineFeatures(
+ ctx context.Context,
+ featureRefs []string,
+ featureService *model.FeatureService,
+ joinKeyToEntityValues map[string]*prototypes.RepeatedValue,
+ requestData map[string]*prototypes.RepeatedValue,
+ fullFeatureNames bool) ([]*onlineserving.FeatureVector, error) {
+ fvs, odFvs, err := fs.ListAllViews()
+ if err != nil {
+ return nil, err
+ }
+
+ entities, err := fs.ListEntities(false)
+ if err != nil {
+ return nil, err
+ }
+
+ var requestedFeatureViews []*onlineserving.FeatureViewAndRefs
+ var requestedOnDemandFeatureViews []*model.OnDemandFeatureView
+ if featureService != nil {
+ requestedFeatureViews, requestedOnDemandFeatureViews, err =
+ onlineserving.GetFeatureViewsToUseByService(featureService, fvs, odFvs)
+ } else {
+ requestedFeatureViews, requestedOnDemandFeatureViews, err =
+ onlineserving.GetFeatureViewsToUseByFeatureRefs(featureRefs, fvs, odFvs)
+ }
+ if err != nil {
+ return nil, err
+ }
+
+ entityNameToJoinKeyMap, expectedJoinKeysSet, err := onlineserving.GetEntityMaps(requestedFeatureViews, entities)
+ if err != nil {
+ return nil, err
+ }
+
+ err = onlineserving.ValidateFeatureRefs(requestedFeatureViews, fullFeatureNames)
+ if err != nil {
+ return nil, err
+ }
+
+ numRows, err := onlineserving.ValidateEntityValues(joinKeyToEntityValues, requestData, expectedJoinKeysSet)
+ if err != nil {
+ return nil, err
+ }
+
+ err = transformation.EnsureRequestedDataExist(requestedOnDemandFeatureViews, requestData)
+ if err != nil {
+ return nil, err
+ }
+
+ result := make([]*onlineserving.FeatureVector, 0)
+ arrowMemory := memory.NewGoAllocator()
+ featureViews := make([]*model.FeatureView, len(requestedFeatureViews))
+ index := 0
+ for _, featuresAndView := range requestedFeatureViews {
+ featureViews[index] = featuresAndView.View
+ index += 1
+ }
+
+ entitylessCase := false
+ for _, featureView := range featureViews {
+ if featureView.HasEntity(model.DUMMY_ENTITY_NAME) {
+ entitylessCase = true
+ break
+ }
+ }
+
+ if entitylessCase {
+ dummyEntityColumn := &prototypes.RepeatedValue{Val: make([]*prototypes.Value, numRows)}
+ for index := 0; index < numRows; index++ {
+ dummyEntityColumn.Val[index] = &model.DUMMY_ENTITY_VALUE
+ }
+ joinKeyToEntityValues[model.DUMMY_ENTITY_ID] = dummyEntityColumn
+ }
+
+ groupedRefs, err := onlineserving.GroupFeatureRefs(requestedFeatureViews, joinKeyToEntityValues, entityNameToJoinKeyMap, fullFeatureNames)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, groupRef := range groupedRefs {
+ featureData, err := fs.readFromOnlineStore(ctx, groupRef.EntityKeys, groupRef.FeatureViewNames, groupRef.FeatureNames)
+ if err != nil {
+ return nil, err
+ }
+
+ vectors, err := onlineserving.TransposeFeatureRowsIntoColumns(
+ featureData,
+ groupRef,
+ requestedFeatureViews,
+ arrowMemory,
+ numRows,
+ )
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, vectors...)
+ }
+
+ if fs.transformationCallback != nil || fs.transformationService != nil {
+ onDemandFeatures, err := transformation.AugmentResponseWithOnDemandTransforms(
+ ctx,
+ requestedOnDemandFeatureViews,
+ requestData,
+ joinKeyToEntityValues,
+ result,
+ fs.transformationCallback,
+ fs.transformationService,
+ arrowMemory,
+ numRows,
+ fullFeatureNames,
+ )
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, onDemandFeatures...)
+ }
+
+ result, err = onlineserving.KeepOnlyRequestedFeatures(result, featureRefs, featureService, fullFeatureNames)
+ if err != nil {
+ return nil, err
+ }
+
+ entityColumns, err := onlineserving.EntitiesToFeatureVectors(joinKeyToEntityValues, arrowMemory, numRows)
+ result = append(entityColumns, result...)
+ return result, nil
+}
+
+func (fs *FeatureStore) DestructOnlineStore() {
+ fs.onlineStore.Destruct()
+}
+
+// ParseFeatures parses the kind field of a GetOnlineFeaturesRequest protobuf message
+// and populates a Features struct with the result.
+func (fs *FeatureStore) ParseFeatures(kind interface{}) (*Features, error) {
+ if featureList, ok := kind.(*serving.GetOnlineFeaturesRequest_Features); ok {
+ return &Features{FeaturesRefs: featureList.Features.GetVal(), FeatureService: nil}, nil
+ }
+ if featureServiceRequest, ok := kind.(*serving.GetOnlineFeaturesRequest_FeatureService); ok {
+ featureService, err := fs.registry.GetFeatureService(fs.config.Project, featureServiceRequest.FeatureService)
+ if err != nil {
+ return nil, err
+ }
+ return &Features{FeaturesRefs: nil, FeatureService: featureService}, nil
+ }
+ return nil, errors.New("cannot parse kind from GetOnlineFeaturesRequest")
+}
+
+func (fs *FeatureStore) GetFeatureService(name string) (*model.FeatureService, error) {
+ return fs.registry.GetFeatureService(fs.config.Project, name)
+}
+
+func (fs *FeatureStore) ListAllViews() (map[string]*model.FeatureView, map[string]*model.OnDemandFeatureView, error) {
+ fvs := make(map[string]*model.FeatureView)
+ odFvs := make(map[string]*model.OnDemandFeatureView)
+
+ featureViews, err := fs.ListFeatureViews()
+ if err != nil {
+ return nil, nil, err
+ }
+ for _, featureView := range featureViews {
+ fvs[featureView.Base.Name] = featureView
+ }
+
+ streamFeatureViews, err := fs.ListStreamFeatureViews()
+ if err != nil {
+ return nil, nil, err
+ }
+ for _, streamFeatureView := range streamFeatureViews {
+ fvs[streamFeatureView.Base.Name] = streamFeatureView
+ }
+
+ onDemandFeatureViews, err := fs.registry.ListOnDemandFeatureViews(fs.config.Project)
+ if err != nil {
+ return nil, nil, err
+ }
+ for _, onDemandFeatureView := range onDemandFeatureViews {
+ odFvs[onDemandFeatureView.Base.Name] = onDemandFeatureView
+ }
+ return fvs, odFvs, nil
+}
+
+func (fs *FeatureStore) ListFeatureViews() ([]*model.FeatureView, error) {
+ featureViews, err := fs.registry.ListFeatureViews(fs.config.Project)
+ if err != nil {
+ return featureViews, err
+ }
+ return featureViews, nil
+}
+
+func (fs *FeatureStore) ListStreamFeatureViews() ([]*model.FeatureView, error) {
+ streamFeatureViews, err := fs.registry.ListStreamFeatureViews(fs.config.Project)
+ if err != nil {
+ return streamFeatureViews, err
+ }
+ return streamFeatureViews, nil
+}
+
+func (fs *FeatureStore) ListEntities(hideDummyEntity bool) ([]*model.Entity, error) {
+
+ allEntities, err := fs.registry.ListEntities(fs.config.Project)
+ if err != nil {
+ return allEntities, err
+ }
+ entities := make([]*model.Entity, 0)
+ for _, entity := range allEntities {
+ if entity.Name != model.DUMMY_ENTITY_NAME || !hideDummyEntity {
+ entities = append(entities, entity)
+ }
+ }
+ return entities, nil
+}
+
+func (fs *FeatureStore) GetEntity(entityName string, hideDummyEntity bool) (*model.Entity, error) {
+
+ entity, err := fs.registry.GetEntity(fs.config.Project, entityName)
+ if err != nil {
+ return nil, err
+ }
+ return entity, nil
+}
+func (fs *FeatureStore) GetRequestSources(odfvList []*model.OnDemandFeatureView) (map[string]prototypes.ValueType_Enum, error) {
+
+ requestSources := make(map[string]prototypes.ValueType_Enum, 0)
+ if len(odfvList) > 0 {
+ for _, odfv := range odfvList {
+ schema := odfv.GetRequestDataSchema()
+ for name, dtype := range schema {
+ requestSources[name] = dtype
+ }
+ }
+ }
+ return requestSources, nil
+}
+
+func (fs *FeatureStore) ListOnDemandFeatureViews() ([]*model.OnDemandFeatureView, error) {
+ return fs.registry.ListOnDemandFeatureViews(fs.config.Project)
+}
+
+/*
+Group feature views that share the same set of join keys. For each group, we store only unique rows and save indices to retrieve those
+rows for each requested feature
+*/
+
+func (fs *FeatureStore) GetFeatureView(featureViewName string, hideDummyEntity bool) (*model.FeatureView, error) {
+ fv, err := fs.registry.GetFeatureView(fs.config.Project, featureViewName)
+ if err != nil {
+ return nil, err
+ }
+ if fv.HasEntity(model.DUMMY_ENTITY_NAME) && hideDummyEntity {
+ fv.EntityNames = []string{}
+ }
+ return fv, nil
+}
+
+func (fs *FeatureStore) GetOnDemandFeatureView(featureViewName string) (*model.OnDemandFeatureView, error) {
+ fv, err := fs.registry.GetOnDemandFeatureView(fs.config.Project, featureViewName)
+ if err != nil {
+ return nil, err
+ }
+ return fv, nil
+}
+
+func (fs *FeatureStore) readFromOnlineStore(ctx context.Context, entityRows []*prototypes.EntityKey,
+ requestedFeatureViewNames []string,
+ requestedFeatureNames []string,
+) ([][]onlinestore.FeatureData, error) {
+ // Create a Datadog span from context
+ span, _ := tracer.StartSpanFromContext(ctx, "fs.readFromOnlineStore")
+ defer span.Finish()
+
+ numRows := len(entityRows)
+ entityRowsValue := make([]*prototypes.EntityKey, numRows)
+ for index, entityKey := range entityRows {
+ entityRowsValue[index] = &prototypes.EntityKey{JoinKeys: entityKey.JoinKeys, EntityValues: entityKey.EntityValues}
+ }
+ return fs.onlineStore.OnlineRead(ctx, entityRowsValue, requestedFeatureViewNames, requestedFeatureNames)
+}
+
+func (fs *FeatureStore) GetFcosMap() (map[string]*model.Entity, map[string]*model.FeatureView, map[string]*model.OnDemandFeatureView, error) {
+ odfvs, err := fs.ListOnDemandFeatureViews()
+ if err != nil {
+ return nil, nil, nil, err
+ }
+ fvs, err := fs.ListFeatureViews()
+ if err != nil {
+ return nil, nil, nil, err
+ }
+ entities, err := fs.ListEntities(true)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+
+ entityMap := make(map[string]*model.Entity)
+ for _, entity := range entities {
+ entityMap[entity.Name] = entity
+ }
+ fvMap := make(map[string]*model.FeatureView)
+ for _, fv := range fvs {
+ fvMap[fv.Base.Name] = fv
+ }
+ odfvMap := make(map[string]*model.OnDemandFeatureView)
+ for _, odfv := range odfvs {
+ odfvMap[odfv.Base.Name] = odfv
+ }
+ return entityMap, fvMap, odfvMap, nil
+}
+
+
+
package onlineserving
+
+import (
+ "crypto/sha256"
+ "errors"
+ "fmt"
+ "sort"
+ "strings"
+
+ "github.com/apache/arrow/go/v8/arrow"
+ "github.com/apache/arrow/go/v8/arrow/memory"
+ "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/types/known/durationpb"
+ "google.golang.org/protobuf/types/known/timestamppb"
+
+ "github.com/feast-dev/feast/go/internal/feast/model"
+ "github.com/feast-dev/feast/go/internal/feast/onlinestore"
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ prototypes "github.com/feast-dev/feast/go/protos/feast/types"
+ "github.com/feast-dev/feast/go/types"
+)
+
+/*
+FeatureVector type represent result of retrieving single feature for multiple rows.
+It can be imagined as a column in output dataframe / table.
+It contains of feature name, list of values (across all rows),
+list of statuses and list of timestamp. All these lists have equal length.
+And this length is also equal to number of entity rows received in request.
+*/
+type FeatureVector struct {
+ Name string
+ Values arrow.Array
+ Statuses []serving.FieldStatus
+ Timestamps []*timestamppb.Timestamp
+}
+
+type FeatureViewAndRefs struct {
+ View *model.FeatureView
+ FeatureRefs []string
+}
+
+/*
+We group all features from a single request by entities they attached to.
+Thus, we will be able to call online retrieval per entity and not per each feature View.
+In this struct we collect all features and views that belongs to a group.
+We also store here projected entity keys (only ones that needed to retrieve these features)
+and indexes to map result of retrieval into output response.
+*/
+type GroupedFeaturesPerEntitySet struct {
+ // A list of requested feature references of the form featureViewName:featureName that share this entity set
+ FeatureNames []string
+ FeatureViewNames []string
+ // full feature references as they supposed to appear in response
+ AliasedFeatureNames []string
+ // Entity set as a list of EntityKeys to pass to OnlineRead
+ EntityKeys []*prototypes.EntityKey
+ // Reversed mapping to project result of retrieval from storage to response
+ Indices [][]int
+}
+
+/*
+Return
+
+ (1) requested feature views and features grouped per View
+ (2) requested on demand feature views
+
+existed in the registry
+*/
+func GetFeatureViewsToUseByService(
+ featureService *model.FeatureService,
+ featureViews map[string]*model.FeatureView,
+ onDemandFeatureViews map[string]*model.OnDemandFeatureView) ([]*FeatureViewAndRefs, []*model.OnDemandFeatureView, error) {
+
+ viewNameToViewAndRefs := make(map[string]*FeatureViewAndRefs)
+ odFvsToUse := make([]*model.OnDemandFeatureView, 0)
+
+ for _, featureProjection := range featureService.Projections {
+ // Create copies of FeatureView that may contains the same *FeatureView but
+ // each differentiated by a *FeatureViewProjection
+ featureViewName := featureProjection.Name
+ if fv, ok := featureViews[featureViewName]; ok {
+ base, err := fv.Base.WithProjection(featureProjection)
+ if err != nil {
+ return nil, nil, err
+ }
+ if _, ok := viewNameToViewAndRefs[featureProjection.NameToUse()]; !ok {
+ viewNameToViewAndRefs[featureProjection.NameToUse()] = &FeatureViewAndRefs{
+ View: fv.NewFeatureViewFromBase(base),
+ FeatureRefs: []string{},
+ }
+ }
+
+ for _, feature := range featureProjection.Features {
+ viewNameToViewAndRefs[featureProjection.NameToUse()].FeatureRefs =
+ addStringIfNotContains(viewNameToViewAndRefs[featureProjection.NameToUse()].FeatureRefs,
+ feature.Name)
+ }
+
+ } else if odFv, ok := onDemandFeatureViews[featureViewName]; ok {
+ projectedOdFv, err := odFv.NewWithProjection(featureProjection)
+ if err != nil {
+ return nil, nil, err
+ }
+ odFvsToUse = append(odFvsToUse, projectedOdFv)
+ err = extractOdFvDependencies(
+ projectedOdFv,
+ featureViews,
+ viewNameToViewAndRefs)
+ if err != nil {
+ return nil, nil, err
+ }
+ } else {
+ return nil, nil, fmt.Errorf("the provided feature service %s contains a reference to a feature View"+
+ "%s which doesn't exist, please make sure that you have created the feature View"+
+ "%s and that you have registered it by running \"apply\"", featureService.Name, featureViewName, featureViewName)
+ }
+ }
+
+ fvsToUse := make([]*FeatureViewAndRefs, 0)
+ for _, viewAndRef := range viewNameToViewAndRefs {
+ fvsToUse = append(fvsToUse, viewAndRef)
+ }
+
+ return fvsToUse, odFvsToUse, nil
+}
+
+/*
+Return
+
+ (1) requested feature views and features grouped per View
+ (2) requested on demand feature views
+
+existed in the registry
+*/
+func GetFeatureViewsToUseByFeatureRefs(
+ features []string,
+ featureViews map[string]*model.FeatureView,
+ onDemandFeatureViews map[string]*model.OnDemandFeatureView) ([]*FeatureViewAndRefs, []*model.OnDemandFeatureView, error) {
+ viewNameToViewAndRefs := make(map[string]*FeatureViewAndRefs)
+ odFvToFeatures := make(map[string][]string)
+
+ for _, featureRef := range features {
+ featureViewName, featureName, err := ParseFeatureReference(featureRef)
+ if err != nil {
+ return nil, nil, err
+ }
+ if fv, ok := featureViews[featureViewName]; ok {
+ if viewAndRef, ok := viewNameToViewAndRefs[fv.Base.Name]; ok {
+ viewAndRef.FeatureRefs = addStringIfNotContains(viewAndRef.FeatureRefs, featureName)
+ } else {
+ viewNameToViewAndRefs[fv.Base.Name] = &FeatureViewAndRefs{
+ View: fv,
+ FeatureRefs: []string{featureName},
+ }
+ }
+ } else if odfv, ok := onDemandFeatureViews[featureViewName]; ok {
+ if _, ok := odFvToFeatures[odfv.Base.Name]; !ok {
+ odFvToFeatures[odfv.Base.Name] = []string{featureName}
+ } else {
+ odFvToFeatures[odfv.Base.Name] = append(
+ odFvToFeatures[odfv.Base.Name], featureName)
+ }
+ } else {
+ return nil, nil, fmt.Errorf("feature View %s doesn't exist, please make sure that you have created the"+
+ " feature View %s and that you have registered it by running \"apply\"", featureViewName, featureViewName)
+ }
+ }
+
+ odFvsToUse := make([]*model.OnDemandFeatureView, 0)
+
+ for odFvName, featureNames := range odFvToFeatures {
+ projectedOdFv, err := onDemandFeatureViews[odFvName].ProjectWithFeatures(featureNames)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ err = extractOdFvDependencies(
+ projectedOdFv,
+ featureViews,
+ viewNameToViewAndRefs)
+ if err != nil {
+ return nil, nil, err
+ }
+ odFvsToUse = append(odFvsToUse, projectedOdFv)
+ }
+
+ fvsToUse := make([]*FeatureViewAndRefs, 0)
+ for _, viewAndRefs := range viewNameToViewAndRefs {
+ fvsToUse = append(fvsToUse, viewAndRefs)
+ }
+
+ return fvsToUse, odFvsToUse, nil
+}
+
+func extractOdFvDependencies(
+ odFv *model.OnDemandFeatureView,
+ sourceFvs map[string]*model.FeatureView,
+ requestedFeatures map[string]*FeatureViewAndRefs,
+) error {
+
+ for _, sourceFvProjection := range odFv.SourceFeatureViewProjections {
+ fv := sourceFvs[sourceFvProjection.Name]
+ base, err := fv.Base.WithProjection(sourceFvProjection)
+ if err != nil {
+ return err
+ }
+ newFv := fv.NewFeatureViewFromBase(base)
+
+ if _, ok := requestedFeatures[sourceFvProjection.NameToUse()]; !ok {
+ requestedFeatures[sourceFvProjection.NameToUse()] = &FeatureViewAndRefs{
+ View: newFv,
+ FeatureRefs: []string{},
+ }
+ }
+
+ for _, feature := range sourceFvProjection.Features {
+ requestedFeatures[sourceFvProjection.NameToUse()].FeatureRefs = addStringIfNotContains(
+ requestedFeatures[sourceFvProjection.NameToUse()].FeatureRefs, feature.Name)
+ }
+ }
+
+ return nil
+}
+
+func addStringIfNotContains(slice []string, element string) []string {
+ found := false
+ for _, item := range slice {
+ if element == item {
+ found = true
+ }
+ }
+ if !found {
+ slice = append(slice, element)
+ }
+ return slice
+}
+
+func GetEntityMaps(requestedFeatureViews []*FeatureViewAndRefs, entities []*model.Entity) (map[string]string, map[string]interface{}, error) {
+ entityNameToJoinKeyMap := make(map[string]string)
+ expectedJoinKeysSet := make(map[string]interface{})
+
+ entitiesByName := make(map[string]*model.Entity)
+
+ for _, entity := range entities {
+ entitiesByName[entity.Name] = entity
+ }
+
+ for _, featuresAndView := range requestedFeatureViews {
+ featureView := featuresAndView.View
+ var joinKeyToAliasMap map[string]string
+ if featureView.Base.Projection != nil && featureView.Base.Projection.JoinKeyMap != nil {
+ joinKeyToAliasMap = featureView.Base.Projection.JoinKeyMap
+ } else {
+ joinKeyToAliasMap = map[string]string{}
+ }
+
+ for _, entityName := range featureView.EntityNames {
+ joinKey := entitiesByName[entityName].JoinKey
+ entityNameToJoinKeyMap[entityName] = joinKey
+
+ if alias, ok := joinKeyToAliasMap[joinKey]; ok {
+ expectedJoinKeysSet[alias] = nil
+ } else {
+ expectedJoinKeysSet[joinKey] = nil
+ }
+ }
+ }
+ return entityNameToJoinKeyMap, expectedJoinKeysSet, nil
+}
+
+func ValidateEntityValues(joinKeyValues map[string]*prototypes.RepeatedValue,
+ requestData map[string]*prototypes.RepeatedValue,
+ expectedJoinKeysSet map[string]interface{}) (int, error) {
+ numRows := -1
+
+ for joinKey, values := range joinKeyValues {
+ if _, ok := expectedJoinKeysSet[joinKey]; !ok {
+ requestData[joinKey] = values
+ delete(joinKeyValues, joinKey)
+ // ToDo: when request data will be passed correctly (not as part of entity rows)
+ // ToDo: throw this error instead
+ // return 0, fmt.Errorf("JoinKey is not expected in this request: %s\n%v", JoinKey, expectedJoinKeysSet)
+ } else {
+ if numRows < 0 {
+ numRows = len(values.Val)
+ } else if len(values.Val) != numRows {
+ return -1, errors.New("valueError: All entity rows must have the same columns")
+ }
+
+ }
+ }
+
+ return numRows, nil
+}
+
+func ValidateFeatureRefs(requestedFeatures []*FeatureViewAndRefs, fullFeatureNames bool) error {
+ featureRefCounter := make(map[string]int)
+ featureRefs := make([]string, 0)
+ for _, viewAndFeatures := range requestedFeatures {
+ for _, feature := range viewAndFeatures.FeatureRefs {
+ projectedViewName := viewAndFeatures.View.Base.Name
+ if viewAndFeatures.View.Base.Projection != nil {
+ projectedViewName = viewAndFeatures.View.Base.Projection.NameToUse()
+ }
+
+ featureRefs = append(featureRefs,
+ fmt.Sprintf("%s:%s", projectedViewName, feature))
+ }
+ }
+
+ for _, featureRef := range featureRefs {
+ if fullFeatureNames {
+ featureRefCounter[featureRef]++
+ } else {
+ _, featureName, _ := ParseFeatureReference(featureRef)
+ featureRefCounter[featureName]++
+ }
+
+ }
+ for featureName, occurrences := range featureRefCounter {
+ if occurrences == 1 {
+ delete(featureRefCounter, featureName)
+ }
+ }
+ if len(featureRefCounter) >= 1 {
+ collidedFeatureRefs := make([]string, 0)
+ for collidedFeatureRef := range featureRefCounter {
+ if fullFeatureNames {
+ collidedFeatureRefs = append(collidedFeatureRefs, collidedFeatureRef)
+ } else {
+ for _, featureRef := range featureRefs {
+ _, featureName, _ := ParseFeatureReference(featureRef)
+ if featureName == collidedFeatureRef {
+ collidedFeatureRefs = append(collidedFeatureRefs, featureRef)
+ }
+ }
+ }
+ }
+ return featureNameCollisionError{collidedFeatureRefs, fullFeatureNames}
+ }
+
+ return nil
+}
+
+func TransposeFeatureRowsIntoColumns(featureData2D [][]onlinestore.FeatureData,
+ groupRef *GroupedFeaturesPerEntitySet,
+ requestedFeatureViews []*FeatureViewAndRefs,
+ arrowAllocator memory.Allocator,
+ numRows int) ([]*FeatureVector, error) {
+
+ numFeatures := len(groupRef.AliasedFeatureNames)
+ fvs := make(map[string]*model.FeatureView)
+ for _, viewAndRefs := range requestedFeatureViews {
+ fvs[viewAndRefs.View.Base.Name] = viewAndRefs.View
+ }
+
+ var value *prototypes.Value
+ var status serving.FieldStatus
+ var eventTimeStamp *timestamppb.Timestamp
+ var featureData *onlinestore.FeatureData
+ var fv *model.FeatureView
+ var featureViewName string
+
+ vectors := make([]*FeatureVector, 0)
+
+ for featureIndex := 0; featureIndex < numFeatures; featureIndex++ {
+ currentVector := &FeatureVector{
+ Name: groupRef.AliasedFeatureNames[featureIndex],
+ Statuses: make([]serving.FieldStatus, numRows),
+ Timestamps: make([]*timestamppb.Timestamp, numRows),
+ }
+ vectors = append(vectors, currentVector)
+ protoValues := make([]*prototypes.Value, numRows)
+
+ for rowEntityIndex, outputIndexes := range groupRef.Indices {
+ if featureData2D[rowEntityIndex] == nil {
+ value = nil
+ status = serving.FieldStatus_NOT_FOUND
+ eventTimeStamp = ×tamppb.Timestamp{}
+ } else {
+ featureData = &featureData2D[rowEntityIndex][featureIndex]
+ eventTimeStamp = ×tamppb.Timestamp{Seconds: featureData.Timestamp.Seconds, Nanos: featureData.Timestamp.Nanos}
+ featureViewName = featureData.Reference.FeatureViewName
+ fv = fvs[featureViewName]
+ if _, ok := featureData.Value.Val.(*prototypes.Value_NullVal); ok {
+ value = nil
+ status = serving.FieldStatus_NOT_FOUND
+ } else if checkOutsideTtl(eventTimeStamp, timestamppb.Now(), fv.Ttl) {
+ value = &prototypes.Value{Val: featureData.Value.Val}
+ status = serving.FieldStatus_OUTSIDE_MAX_AGE
+ } else {
+ value = &prototypes.Value{Val: featureData.Value.Val}
+ status = serving.FieldStatus_PRESENT
+ }
+ }
+ for _, rowIndex := range outputIndexes {
+ protoValues[rowIndex] = value
+ currentVector.Statuses[rowIndex] = status
+ currentVector.Timestamps[rowIndex] = eventTimeStamp
+ }
+ }
+ arrowValues, err := types.ProtoValuesToArrowArray(protoValues, arrowAllocator, numRows)
+ if err != nil {
+ return nil, err
+ }
+ currentVector.Values = arrowValues
+ }
+
+ return vectors, nil
+
+}
+
+func KeepOnlyRequestedFeatures(
+ vectors []*FeatureVector,
+ requestedFeatureRefs []string,
+ featureService *model.FeatureService,
+ fullFeatureNames bool) ([]*FeatureVector, error) {
+ vectorsByName := make(map[string]*FeatureVector)
+ expectedVectors := make([]*FeatureVector, 0)
+
+ usedVectors := make(map[string]bool)
+
+ for _, vector := range vectors {
+ vectorsByName[vector.Name] = vector
+ }
+
+ if featureService != nil {
+ for _, projection := range featureService.Projections {
+ for _, f := range projection.Features {
+ requestedFeatureRefs = append(requestedFeatureRefs,
+ fmt.Sprintf("%s:%s", projection.NameToUse(), f.Name))
+ }
+ }
+ }
+
+ for _, featureRef := range requestedFeatureRefs {
+ viewName, featureName, err := ParseFeatureReference(featureRef)
+ if err != nil {
+ return nil, err
+ }
+ qualifiedName := getQualifiedFeatureName(viewName, featureName, fullFeatureNames)
+ if _, ok := vectorsByName[qualifiedName]; !ok {
+ return nil, fmt.Errorf("requested feature %s can't be retrieved", featureRef)
+ }
+ expectedVectors = append(expectedVectors, vectorsByName[qualifiedName])
+ usedVectors[qualifiedName] = true
+ }
+
+ // Free arrow arrays for vectors that were not used.
+ for _, vector := range vectors {
+ if _, ok := usedVectors[vector.Name]; !ok {
+ vector.Values.Release()
+ }
+ }
+
+ return expectedVectors, nil
+}
+
+func EntitiesToFeatureVectors(entityColumns map[string]*prototypes.RepeatedValue, arrowAllocator memory.Allocator, numRows int) ([]*FeatureVector, error) {
+ vectors := make([]*FeatureVector, 0)
+ presentVector := make([]serving.FieldStatus, numRows)
+ timestampVector := make([]*timestamppb.Timestamp, numRows)
+ for idx := 0; idx < numRows; idx++ {
+ presentVector[idx] = serving.FieldStatus_PRESENT
+ timestampVector[idx] = timestamppb.Now()
+ }
+ for entityName, values := range entityColumns {
+ arrowColumn, err := types.ProtoValuesToArrowArray(values.Val, arrowAllocator, numRows)
+ if err != nil {
+ return nil, err
+ }
+ vectors = append(vectors, &FeatureVector{
+ Name: entityName,
+ Values: arrowColumn,
+ Statuses: presentVector,
+ Timestamps: timestampVector,
+ })
+ }
+ return vectors, nil
+}
+
+func ParseFeatureReference(featureRef string) (featureViewName, featureName string, e error) {
+ parsedFeatureName := strings.Split(featureRef, ":")
+
+ if len(parsedFeatureName) == 0 {
+ e = errors.New("featureReference should be in the format: 'FeatureViewName:FeatureName'")
+ } else if len(parsedFeatureName) == 1 {
+ featureName = parsedFeatureName[0]
+ } else {
+ featureViewName = parsedFeatureName[0]
+ featureName = parsedFeatureName[1]
+ }
+ return
+}
+
+func entityKeysToProtos(joinKeyValues map[string]*prototypes.RepeatedValue) []*prototypes.EntityKey {
+ keys := make([]string, len(joinKeyValues))
+ index := 0
+ var numRows int
+ for k, v := range joinKeyValues {
+ keys[index] = k
+ index += 1
+ numRows = len(v.Val)
+ }
+ sort.Strings(keys)
+ entityKeys := make([]*prototypes.EntityKey, numRows)
+ numJoinKeys := len(keys)
+ // Construct each EntityKey object
+ for index = 0; index < numRows; index++ {
+ entityKeys[index] = &prototypes.EntityKey{JoinKeys: keys, EntityValues: make([]*prototypes.Value, numJoinKeys)}
+ }
+
+ for colIndex, key := range keys {
+ for index, value := range joinKeyValues[key].GetVal() {
+ entityKeys[index].EntityValues[colIndex] = value
+ }
+ }
+ return entityKeys
+}
+
+func GroupFeatureRefs(requestedFeatureViews []*FeatureViewAndRefs,
+ joinKeyValues map[string]*prototypes.RepeatedValue,
+ entityNameToJoinKeyMap map[string]string,
+ fullFeatureNames bool,
+) (map[string]*GroupedFeaturesPerEntitySet,
+ error,
+) {
+ groups := make(map[string]*GroupedFeaturesPerEntitySet)
+
+ for _, featuresAndView := range requestedFeatureViews {
+ joinKeys := make([]string, 0)
+ fv := featuresAndView.View
+ featureNames := featuresAndView.FeatureRefs
+ for _, entityName := range fv.EntityNames {
+ joinKeys = append(joinKeys, entityNameToJoinKeyMap[entityName])
+ }
+
+ groupKeyBuilder := make([]string, 0)
+ joinKeysValuesProjection := make(map[string]*prototypes.RepeatedValue)
+
+ joinKeyToAliasMap := make(map[string]string)
+ if fv.Base.Projection != nil && fv.Base.Projection.JoinKeyMap != nil {
+ joinKeyToAliasMap = fv.Base.Projection.JoinKeyMap
+ }
+
+ for _, joinKey := range joinKeys {
+ var joinKeyOrAlias string
+
+ if alias, ok := joinKeyToAliasMap[joinKey]; ok {
+ groupKeyBuilder = append(groupKeyBuilder, fmt.Sprintf("%s[%s]", joinKey, alias))
+ joinKeyOrAlias = alias
+ } else {
+ groupKeyBuilder = append(groupKeyBuilder, joinKey)
+ joinKeyOrAlias = joinKey
+ }
+
+ if _, ok := joinKeyValues[joinKeyOrAlias]; !ok {
+ return nil, fmt.Errorf("key %s is missing in provided entity rows", joinKey)
+ }
+ joinKeysValuesProjection[joinKey] = joinKeyValues[joinKeyOrAlias]
+ }
+
+ sort.Strings(groupKeyBuilder)
+ groupKey := strings.Join(groupKeyBuilder, ",")
+
+ aliasedFeatureNames := make([]string, 0)
+ featureViewNames := make([]string, 0)
+ var viewNameToUse string
+ if fv.Base.Projection != nil {
+ viewNameToUse = fv.Base.Projection.NameToUse()
+ } else {
+ viewNameToUse = fv.Base.Name
+ }
+
+ for _, featureName := range featureNames {
+ aliasedFeatureNames = append(aliasedFeatureNames,
+ getQualifiedFeatureName(viewNameToUse, featureName, fullFeatureNames))
+ featureViewNames = append(featureViewNames, fv.Base.Name)
+ }
+
+ if _, ok := groups[groupKey]; !ok {
+ joinKeysProto := entityKeysToProtos(joinKeysValuesProjection)
+ uniqueEntityRows, mappingIndices, err := getUniqueEntityRows(joinKeysProto)
+ if err != nil {
+ return nil, err
+ }
+
+ groups[groupKey] = &GroupedFeaturesPerEntitySet{
+ FeatureNames: featureNames,
+ FeatureViewNames: featureViewNames,
+ AliasedFeatureNames: aliasedFeatureNames,
+ Indices: mappingIndices,
+ EntityKeys: uniqueEntityRows,
+ }
+
+ } else {
+ groups[groupKey].FeatureNames = append(groups[groupKey].FeatureNames, featureNames...)
+ groups[groupKey].AliasedFeatureNames = append(groups[groupKey].AliasedFeatureNames, aliasedFeatureNames...)
+ groups[groupKey].FeatureViewNames = append(groups[groupKey].FeatureViewNames, featureViewNames...)
+ }
+ }
+ return groups, nil
+}
+
+func getUniqueEntityRows(joinKeysProto []*prototypes.EntityKey) ([]*prototypes.EntityKey, [][]int, error) {
+ uniqueValues := make(map[[sha256.Size]byte]*prototypes.EntityKey, 0)
+ positions := make(map[[sha256.Size]byte][]int, 0)
+
+ for index, entityKey := range joinKeysProto {
+ serializedRow, err := proto.Marshal(entityKey)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ rowHash := sha256.Sum256(serializedRow)
+ if _, ok := uniqueValues[rowHash]; !ok {
+ uniqueValues[rowHash] = entityKey
+ positions[rowHash] = []int{index}
+ } else {
+ positions[rowHash] = append(positions[rowHash], index)
+ }
+ }
+
+ mappingIndices := make([][]int, len(uniqueValues))
+ uniqueEntityRows := make([]*prototypes.EntityKey, 0)
+ for rowHash, row := range uniqueValues {
+ nextIdx := len(uniqueEntityRows)
+
+ mappingIndices[nextIdx] = positions[rowHash]
+ uniqueEntityRows = append(uniqueEntityRows, row)
+ }
+ return uniqueEntityRows, mappingIndices, nil
+}
+
+func checkOutsideTtl(featureTimestamp *timestamppb.Timestamp, currentTimestamp *timestamppb.Timestamp, ttl *durationpb.Duration) bool {
+ if ttl.Seconds == 0 {
+ return false
+ }
+ return currentTimestamp.GetSeconds()-featureTimestamp.GetSeconds() > ttl.Seconds
+}
+
+func getQualifiedFeatureName(viewName string, featureName string, fullFeatureNames bool) string {
+ if fullFeatureNames {
+ return fmt.Sprintf("%s__%s", viewName, featureName)
+ } else {
+ return featureName
+ }
+}
+
+type featureNameCollisionError struct {
+ featureRefCollisions []string
+ fullFeatureNames bool
+}
+
+func (e featureNameCollisionError) Error() string {
+ return fmt.Sprintf("featureNameCollisionError: %s; %t", strings.Join(e.featureRefCollisions, ", "), e.fullFeatureNames)
+}
+
+
+
package onlinestore
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/feast-dev/feast/go/internal/feast/registry"
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ "github.com/feast-dev/feast/go/protos/feast/types"
+ "github.com/golang/protobuf/ptypes/timestamp"
+)
+
+type FeatureData struct {
+ Reference serving.FeatureReferenceV2
+ Timestamp timestamp.Timestamp
+ Value types.Value
+}
+
+type OnlineStore interface {
+ // OnlineRead reads multiple features (specified in featureReferences) for multiple
+ // entity keys (specified in entityKeys) and returns an array of array of features,
+ // where each feature contains 3 fields:
+ // 1. feature Reference
+ // 2. feature event timestamp
+ // 3. feature value
+ // The inner array will have the same size as featureReferences,
+ // while the outer array will have the same size as entityKeys.
+
+ // TODO: Can we return [][]FeatureData, []timstamps, error
+ // instead and remove timestamp from FeatureData struct to mimic Python's code
+ // and reduces repeated memory storage for the same timstamp (which is stored as value and not as a pointer).
+ // Should each attribute in FeatureData be stored as a pointer instead since the current
+ // design forces value copied in OnlineRead + GetOnlineFeatures
+ // (array is destructed so we cannot use the same fields in each
+ // Feature object as pointers in GetOnlineFeaturesResponse)
+ // => allocate memory for each field once in OnlineRead
+ // and reuse them in GetOnlineFeaturesResponse?
+ OnlineRead(ctx context.Context, entityKeys []*types.EntityKey, featureViewNames []string, featureNames []string) ([][]FeatureData, error)
+ // Destruct must be call once user is done using OnlineStore
+ // This is to comply with the Connector since we have to close the plugin
+ Destruct()
+}
+
+func getOnlineStoreType(onlineStoreConfig map[string]interface{}) (string, bool) {
+ if onlineStoreType, ok := onlineStoreConfig["type"]; !ok {
+ // If online store type isn't specified, default to sqlite
+ return "sqlite", true
+ } else {
+ result, ok := onlineStoreType.(string)
+ return result, ok
+ }
+}
+
+func NewOnlineStore(config *registry.RepoConfig) (OnlineStore, error) {
+ onlineStoreType, ok := getOnlineStoreType(config.OnlineStore)
+ if !ok {
+ return nil, fmt.Errorf("could not get online store type from online store config: %+v", config.OnlineStore)
+ } else if onlineStoreType == "sqlite" {
+ onlineStore, err := NewSqliteOnlineStore(config.Project, config, config.OnlineStore)
+ return onlineStore, err
+ } else if onlineStoreType == "redis" {
+ onlineStore, err := NewRedisOnlineStore(config.Project, config, config.OnlineStore)
+ return onlineStore, err
+ } else {
+ return nil, fmt.Errorf("%s online store type is currently not supported; only redis and sqlite are supported", onlineStoreType)
+ }
+}
+
+
+
package onlinestore
+
+import (
+ "context"
+ "crypto/tls"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "os"
+ "sort"
+ "strconv"
+ "strings"
+
+ "github.com/feast-dev/feast/go/internal/feast/registry"
+ "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+
+ "github.com/redis/go-redis/v9"
+ "github.com/spaolacci/murmur3"
+ "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/types/known/timestamppb"
+
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ "github.com/feast-dev/feast/go/protos/feast/types"
+ redistrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/redis/go-redis.v9"
+)
+
+type redisType int
+
+const (
+ redisNode redisType = 0
+ redisCluster redisType = 1
+)
+
+type RedisOnlineStore struct {
+
+ // Feast project name
+ // TODO (woop): Should we remove project as state that is tracked at the store level?
+ project string
+
+ // Redis database type, either a single node server (RedisType.Redis) or a cluster (RedisType.RedisCluster)
+ t redisType
+
+ // Redis client connector
+ client *redis.Client
+
+ // Redis cluster client connector
+ clusterClient *redis.ClusterClient
+
+ config *registry.RepoConfig
+}
+
+func NewRedisOnlineStore(project string, config *registry.RepoConfig, onlineStoreConfig map[string]interface{}) (*RedisOnlineStore, error) {
+ store := RedisOnlineStore{
+ project: project,
+ config: config,
+ }
+
+ var address []string
+ var password string
+ var tlsConfig *tls.Config
+ var db int // Default to 0
+
+ // Parse redis_type and write it into conf.redisStoreType
+ redisStoreType, err := getRedisType(onlineStoreConfig)
+ if err != nil {
+ return nil, err
+ }
+ store.t = redisStoreType
+
+ // Parse connection_string and write it into conf.address, conf.password, and conf.ssl
+ redisConnJson, ok := onlineStoreConfig["connection_string"]
+ if !ok {
+ // Default to "localhost:6379"
+ redisConnJson = "localhost:6379"
+ }
+ if redisConnStr, ok := redisConnJson.(string); !ok {
+ return nil, fmt.Errorf("failed to convert connection_string to string: %+v", redisConnJson)
+ } else {
+ parts := strings.Split(redisConnStr, ",")
+ for _, part := range parts {
+ if strings.Contains(part, ":") {
+ address = append(address, part)
+ } else if strings.Contains(part, "=") {
+ kv := strings.SplitN(part, "=", 2)
+ if kv[0] == "password" {
+ password = kv[1]
+ } else if kv[0] == "ssl" {
+ result, err := strconv.ParseBool(kv[1])
+ if err != nil {
+ return nil, err
+ } else if result {
+ tlsConfig = &tls.Config{}
+ }
+ } else if kv[0] == "db" {
+ db, err = strconv.Atoi(kv[1])
+ if err != nil {
+ return nil, err
+ }
+ } else {
+ return nil, fmt.Errorf("unrecognized option in connection_string: %s. Must be one of 'password', 'ssl'", kv[0])
+ }
+ } else {
+ return nil, fmt.Errorf("unable to parse a part of connection_string: %s. Must contain either ':' (addresses) or '=' (options", part)
+ }
+ }
+ }
+
+ // Metrics are not showing up when the service name is set to DD_SERVICE
+ redisTraceServiceName := os.Getenv("DD_SERVICE") + "-redis"
+ if redisTraceServiceName == "" {
+ redisTraceServiceName = "redis.client" // default service name if DD_SERVICE is not set
+ }
+
+ if redisStoreType == redisNode {
+ store.client = redis.NewClient(&redis.Options{
+ Addr: address[0],
+ Password: password, // No password set
+ DB: db,
+ TLSConfig: tlsConfig,
+ })
+ if strings.ToLower(os.Getenv("ENABLE_DATADOG_REDIS_TRACING")) == "true" {
+ redistrace.WrapClient(store.client, redistrace.WithServiceName(redisTraceServiceName))
+ }
+ } else if redisStoreType == redisCluster {
+ store.clusterClient = redis.NewClusterClient(&redis.ClusterOptions{
+ Addrs: []string{address[0]},
+ Password: password, // No password set
+ TLSConfig: tlsConfig,
+ ReadOnly: true,
+ })
+ if strings.ToLower(os.Getenv("ENABLE_DATADOG_REDIS_TRACING")) == "true" {
+ redistrace.WrapClient(store.clusterClient, redistrace.WithServiceName(redisTraceServiceName))
+ }
+ }
+
+ return &store, nil
+}
+
+func getRedisType(onlineStoreConfig map[string]interface{}) (redisType, error) {
+ var t redisType
+
+ redisTypeJson, ok := onlineStoreConfig["redis_type"]
+ if !ok {
+ // Default to "redis"
+ redisTypeJson = "redis"
+ } else if redisTypeStr, ok := redisTypeJson.(string); !ok {
+ return -1, fmt.Errorf("failed to convert redis_type to string: %+v", redisTypeJson)
+ } else {
+ if redisTypeStr == "redis" {
+ t = redisNode
+ } else if redisTypeStr == "redis_cluster" {
+ t = redisCluster
+ } else {
+ return -1, fmt.Errorf("failed to convert redis_type to enum: %s. Must be one of 'redis', 'redis_cluster'", redisTypeStr)
+ }
+ }
+ return t, nil
+}
+
+func (r *RedisOnlineStore) buildFeatureViewIndices(featureViewNames []string, featureNames []string) (map[string]int, map[int]string, int) {
+ featureViewIndices := make(map[string]int)
+ indicesFeatureView := make(map[int]string)
+ index := len(featureNames)
+ for _, featureViewName := range featureViewNames {
+ if _, ok := featureViewIndices[featureViewName]; !ok {
+ featureViewIndices[featureViewName] = index
+ indicesFeatureView[index] = featureViewName
+ index += 1
+ }
+ }
+ return featureViewIndices, indicesFeatureView, index
+}
+
+func (r *RedisOnlineStore) buildHsetKeys(featureViewNames []string, featureNames []string, indicesFeatureView map[int]string, index int) ([]string, []string) {
+ featureCount := len(featureNames)
+ var hsetKeys = make([]string, index)
+ h := murmur3.New32()
+ intBuffer := h.Sum32()
+ byteBuffer := make([]byte, 4)
+
+ for i := 0; i < featureCount; i++ {
+ h.Write([]byte(fmt.Sprintf("%s:%s", featureViewNames[i], featureNames[i])))
+ intBuffer = h.Sum32()
+ binary.LittleEndian.PutUint32(byteBuffer, intBuffer)
+ hsetKeys[i] = string(byteBuffer)
+ h.Reset()
+ }
+ for i := featureCount; i < index; i++ {
+ view := indicesFeatureView[i]
+ tsKey := fmt.Sprintf("_ts:%s", view)
+ hsetKeys[i] = tsKey
+ featureNames = append(featureNames, tsKey)
+ }
+ return hsetKeys, featureNames
+}
+
+func (r *RedisOnlineStore) buildRedisKeys(entityKeys []*types.EntityKey) ([]*[]byte, map[string]int, error) {
+ redisKeys := make([]*[]byte, len(entityKeys))
+ redisKeyToEntityIndex := make(map[string]int)
+ for i := 0; i < len(entityKeys); i++ {
+ var key, err = buildRedisKey(r.project, entityKeys[i], r.config.EntityKeySerializationVersion)
+ if err != nil {
+ return nil, nil, err
+ }
+ redisKeys[i] = key
+ redisKeyToEntityIndex[string(*key)] = i
+ }
+ return redisKeys, redisKeyToEntityIndex, nil
+}
+
+func (r *RedisOnlineStore) OnlineRead(ctx context.Context, entityKeys []*types.EntityKey, featureViewNames []string, featureNames []string) ([][]FeatureData, error) {
+ span, _ := tracer.StartSpanFromContext(ctx, "redis.OnlineRead")
+ defer span.Finish()
+
+ featureCount := len(featureNames)
+ featureViewIndices, indicesFeatureView, index := r.buildFeatureViewIndices(featureViewNames, featureNames)
+ hsetKeys, featureNamesWithTimeStamps := r.buildHsetKeys(featureViewNames, featureNames, indicesFeatureView, index)
+ redisKeys, redisKeyToEntityIndex, err := r.buildRedisKeys(entityKeys)
+ if err != nil {
+ return nil, err
+ }
+
+ results := make([][]FeatureData, len(entityKeys))
+ commands := map[string]*redis.SliceCmd{}
+
+ if r.t == redisNode {
+ pipe := r.client.Pipeline()
+ for _, redisKey := range redisKeys {
+ keyString := string(*redisKey)
+ commands[keyString] = pipe.HMGet(ctx, keyString, hsetKeys...)
+ }
+ _, err = pipe.Exec(ctx)
+ if err != nil {
+ return nil, err
+ }
+ } else if r.t == redisCluster {
+ pipe := r.clusterClient.Pipeline()
+ for _, redisKey := range redisKeys {
+ keyString := string(*redisKey)
+ commands[keyString] = pipe.HMGet(ctx, keyString, hsetKeys...)
+ }
+ _, err = pipe.Exec(ctx)
+ if err != nil {
+ return nil, err
+ }
+ }
+ var entityIndex int
+ var resContainsNonNil bool
+ for redisKey, values := range commands {
+
+ entityIndex = redisKeyToEntityIndex[redisKey]
+ resContainsNonNil = false
+
+ results[entityIndex] = make([]FeatureData, featureCount)
+ res, err := values.Result()
+ if err != nil {
+ return nil, err
+ }
+
+ var timeStamp timestamppb.Timestamp
+
+ for featureIndex, resString := range res {
+ if featureIndex == featureCount {
+ break
+ }
+
+ if resString == nil {
+ // TODO (Ly): Can there be nil result within each feature or they will all be returned as string proto of types.Value_NullVal proto?
+ featureName := featureNamesWithTimeStamps[featureIndex]
+ featureViewName := featureViewNames[featureIndex]
+ timeStampIndex := featureViewIndices[featureViewName]
+ timeStampInterface := res[timeStampIndex]
+ if timeStampInterface != nil {
+ if timeStampString, ok := timeStampInterface.(string); !ok {
+ return nil, errors.New("error parsing value from redis")
+ } else {
+ if err := proto.Unmarshal([]byte(timeStampString), &timeStamp); err != nil {
+ return nil, errors.New("error converting parsed redis value to timestamppb.Timestamp")
+ }
+ }
+ }
+
+ results[entityIndex][featureIndex] = FeatureData{Reference: serving.FeatureReferenceV2{FeatureViewName: featureViewName, FeatureName: featureName},
+ Timestamp: timestamppb.Timestamp{Seconds: timeStamp.Seconds, Nanos: timeStamp.Nanos},
+ Value: types.Value{Val: &types.Value_NullVal{NullVal: types.Null_NULL}},
+ }
+
+ } else if valueString, ok := resString.(string); !ok {
+ return nil, errors.New("error parsing Value from redis")
+ } else {
+ resContainsNonNil = true
+ var value types.Value
+ if err := proto.Unmarshal([]byte(valueString), &value); err != nil {
+ return nil, errors.New("error converting parsed redis Value to types.Value")
+ } else {
+ featureName := featureNamesWithTimeStamps[featureIndex]
+ featureViewName := featureViewNames[featureIndex]
+ timeStampIndex := featureViewIndices[featureViewName]
+ timeStampInterface := res[timeStampIndex]
+ if timeStampInterface != nil {
+ if timeStampString, ok := timeStampInterface.(string); !ok {
+ return nil, errors.New("error parsing Value from redis")
+ } else {
+ if err := proto.Unmarshal([]byte(timeStampString), &timeStamp); err != nil {
+ return nil, errors.New("error converting parsed redis Value to timestamppb.Timestamp")
+ }
+ }
+ }
+ results[entityIndex][featureIndex] = FeatureData{Reference: serving.FeatureReferenceV2{FeatureViewName: featureViewName, FeatureName: featureName},
+ Timestamp: timestamppb.Timestamp{Seconds: timeStamp.Seconds, Nanos: timeStamp.Nanos},
+ Value: types.Value{Val: value.Val},
+ }
+ }
+ }
+ }
+
+ if !resContainsNonNil {
+ results[entityIndex] = nil
+ }
+
+ }
+
+ return results, nil
+}
+
+// Dummy destruct function to conform with plugin OnlineStore interface
+func (r *RedisOnlineStore) Destruct() {
+
+}
+
+func buildRedisKey(project string, entityKey *types.EntityKey, entityKeySerializationVersion int64) (*[]byte, error) {
+ serKey, err := serializeEntityKey(entityKey, entityKeySerializationVersion)
+ if err != nil {
+ return nil, err
+ }
+ fullKey := append(*serKey, []byte(project)...)
+ return &fullKey, nil
+}
+
+func serializeEntityKey(entityKey *types.EntityKey, entityKeySerializationVersion int64) (*[]byte, error) {
+ // Serialize entity key to a bytestring so that it can be used as a lookup key in a hash table.
+
+ // Ensure that we have the right amount of join keys and entity values
+ if len(entityKey.JoinKeys) != len(entityKey.EntityValues) {
+ return nil, fmt.Errorf("the amount of join key names and entity values don't match: %s vs %s", entityKey.JoinKeys, entityKey.EntityValues)
+ }
+
+ // Make sure that join keys are sorted so that we have consistent key building
+ m := make(map[string]*types.Value)
+
+ for i := 0; i < len(entityKey.JoinKeys); i++ {
+ m[entityKey.JoinKeys[i]] = entityKey.EntityValues[i]
+ }
+
+ keys := make([]string, 0, len(m))
+ for k := range entityKey.JoinKeys {
+ keys = append(keys, entityKey.JoinKeys[k])
+ }
+ sort.Strings(keys)
+
+ // Build the key
+ length := 5 * len(keys)
+ bufferList := make([][]byte, length)
+
+ for i := 0; i < len(keys); i++ {
+ offset := i * 2
+ byteBuffer := make([]byte, 4)
+ binary.LittleEndian.PutUint32(byteBuffer, uint32(types.ValueType_Enum_value["STRING"]))
+ bufferList[offset] = byteBuffer
+ bufferList[offset+1] = []byte(keys[i])
+ }
+
+ for i := 0; i < len(keys); i++ {
+ offset := (2 * len(keys)) + (i * 3)
+ value := m[keys[i]].GetVal()
+
+ valueBytes, valueTypeBytes, err := serializeValue(value, entityKeySerializationVersion)
+ if err != nil {
+ return valueBytes, err
+ }
+
+ typeBuffer := make([]byte, 4)
+ binary.LittleEndian.PutUint32(typeBuffer, uint32(valueTypeBytes))
+
+ lenBuffer := make([]byte, 4)
+ binary.LittleEndian.PutUint32(lenBuffer, uint32(len(*valueBytes)))
+
+ bufferList[offset+0] = typeBuffer
+ bufferList[offset+1] = lenBuffer
+ bufferList[offset+2] = *valueBytes
+ }
+
+ // Convert from an array of byte arrays to a single byte array
+ var entityKeyBuffer []byte
+ for i := 0; i < len(bufferList); i++ {
+ entityKeyBuffer = append(entityKeyBuffer, bufferList[i]...)
+ }
+
+ return &entityKeyBuffer, nil
+}
+
+func serializeValue(value interface{}, entityKeySerializationVersion int64) (*[]byte, types.ValueType_Enum, error) {
+ // TODO: Implement support for other types (at least the major types like ints, strings, bytes)
+ switch x := (value).(type) {
+ case *types.Value_StringVal:
+ valueString := []byte(x.StringVal)
+ return &valueString, types.ValueType_STRING, nil
+ case *types.Value_BytesVal:
+ return &x.BytesVal, types.ValueType_BYTES, nil
+ case *types.Value_Int32Val:
+ valueBuffer := make([]byte, 4)
+ binary.LittleEndian.PutUint32(valueBuffer, uint32(x.Int32Val))
+ return &valueBuffer, types.ValueType_INT32, nil
+ case *types.Value_Int64Val:
+ if entityKeySerializationVersion <= 1 {
+ // We unfortunately have to use 32 bit here for backward compatibility :(
+ valueBuffer := make([]byte, 4)
+ binary.LittleEndian.PutUint32(valueBuffer, uint32(x.Int64Val))
+ return &valueBuffer, types.ValueType_INT64, nil
+ } else {
+ valueBuffer := make([]byte, 8)
+ binary.LittleEndian.PutUint64(valueBuffer, uint64(x.Int64Val))
+ return &valueBuffer, types.ValueType_INT64, nil
+ }
+ case nil:
+ return nil, types.ValueType_INVALID, fmt.Errorf("could not detect type for %v", x)
+ default:
+ return nil, types.ValueType_INVALID, fmt.Errorf("could not detect type for %v", x)
+ }
+}
+
+
+
package onlinestore
+
+import (
+ "crypto/sha1"
+ "database/sql"
+ "encoding/hex"
+ "errors"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/feast-dev/feast/go/internal/feast/registry"
+
+ "context"
+ "fmt"
+
+ _ "github.com/mattn/go-sqlite3"
+ "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/types/known/timestamppb"
+
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ "github.com/feast-dev/feast/go/protos/feast/types"
+)
+
+type SqliteOnlineStore struct {
+ // Feast project name
+ project string
+ path string
+ db *sql.DB
+ db_mu sync.Mutex
+ repoConfig *registry.RepoConfig
+}
+
+// Creates a new sqlite online store object. onlineStoreConfig should have relative path of database file with respect to repoConfig.repoPath.
+func NewSqliteOnlineStore(project string, repoConfig *registry.RepoConfig, onlineStoreConfig map[string]interface{}) (*SqliteOnlineStore, error) {
+ store := SqliteOnlineStore{project: project, repoConfig: repoConfig}
+ if db_path, ok := onlineStoreConfig["path"]; !ok {
+ return nil, fmt.Errorf("cannot find sqlite path %s", db_path)
+ } else {
+ if dbPathStr, ok := db_path.(string); !ok {
+ return nil, fmt.Errorf("cannot find convert sqlite path to string %s", db_path)
+ } else {
+ store.path = fmt.Sprintf("%s/%s", repoConfig.RepoPath, dbPathStr)
+
+ db, err := initializeConnection(store.path)
+ if err != nil {
+ return nil, err
+ }
+ store.db = db
+ }
+ }
+
+ return &store, nil
+}
+
+func (s *SqliteOnlineStore) Destruct() {
+ s.db.Close()
+}
+
+// Returns FeatureData 2D array. Each row corresponds to one entity Value and each column corresponds to a single feature where the number of columns should be
+// same length as the length of featureNames. Reads from every table in featureViewNames with the entity keys described.
+func (s *SqliteOnlineStore) OnlineRead(ctx context.Context, entityKeys []*types.EntityKey, featureViewNames []string, featureNames []string) ([][]FeatureData, error) {
+ featureCount := len(featureNames)
+ _, err := s.getConnection()
+ if err != nil {
+ return nil, err
+ }
+ project := s.project
+ results := make([][]FeatureData, len(entityKeys))
+ entityNameToEntityIndex := make(map[string]int)
+ in_query := make([]string, len(entityKeys))
+ serialized_entities := make([]interface{}, len(entityKeys))
+ for i := 0; i < len(entityKeys); i++ {
+ serKey, err := serializeEntityKey(entityKeys[i], s.repoConfig.EntityKeySerializationVersion)
+ if err != nil {
+ return nil, err
+ }
+ // TODO: fix this, string conversion is not safe
+ entityNameToEntityIndex[hashSerializedEntityKey(serKey)] = i
+ // for IN clause in read query
+ in_query[i] = "?"
+ serialized_entities[i] = *serKey
+ }
+ featureNamesToIdx := make(map[string]int)
+ for idx, name := range featureNames {
+ featureNamesToIdx[name] = idx
+ }
+
+ for _, featureViewName := range featureViewNames {
+ query_string := fmt.Sprintf(`SELECT entity_key, feature_name, Value, event_ts
+ FROM %s
+ WHERE entity_key IN (%s)
+ ORDER BY entity_key`, tableId(project, featureViewName), strings.Join(in_query, ","))
+ rows, err := s.db.Query(query_string, serialized_entities...)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var entity_key []byte
+ var feature_name string
+ var valueString []byte
+ var event_ts time.Time
+ var value types.Value
+ err = rows.Scan(&entity_key, &feature_name, &valueString, &event_ts)
+ if err != nil {
+ return nil, errors.New("error could not resolve row in query (entity key, feature name, value, event ts)")
+ }
+ if err := proto.Unmarshal(valueString, &value); err != nil {
+ return nil, errors.New("error converting parsed value to types.Value")
+ }
+ rowIdx := entityNameToEntityIndex[hashSerializedEntityKey(&entity_key)]
+ if results[rowIdx] == nil {
+ results[rowIdx] = make([]FeatureData, featureCount)
+ }
+ results[rowIdx][featureNamesToIdx[feature_name]] = FeatureData{Reference: serving.FeatureReferenceV2{FeatureViewName: featureViewName, FeatureName: feature_name},
+ Timestamp: *timestamppb.New(event_ts),
+ Value: types.Value{Val: value.Val},
+ }
+ }
+ }
+ return results, nil
+}
+
+// Gets a sqlite connection and sets it to the online store and also returns a pointer to the connection.
+func (s *SqliteOnlineStore) getConnection() (*sql.DB, error) {
+ s.db_mu.Lock()
+ defer s.db_mu.Unlock()
+ if s.db == nil {
+ if s.path == "" {
+ return nil, errors.New("no database path available")
+ }
+ db, err := initializeConnection(s.path)
+ s.db = db
+ if err != nil {
+ return nil, err
+ }
+ }
+ return s.db, nil
+}
+
+// Constructs the table id from the project and table(featureViewName) string.
+func tableId(project string, featureViewName string) string {
+ return fmt.Sprintf("%s_%s", project, featureViewName)
+}
+
+// Creates a connection to the sqlite database and returns the connection.
+func initializeConnection(db_path string) (*sql.DB, error) {
+ db, err := sql.Open("sqlite3", db_path)
+ if err != nil {
+ return nil, err
+ }
+ return db, nil
+}
+
+func hashSerializedEntityKey(serializedEntityKey *[]byte) string {
+ if serializedEntityKey == nil {
+ return ""
+ }
+ h := sha1.New()
+ h.Write(*serializedEntityKey)
+ sha1_hash := hex.EncodeToString(h.Sum(nil))
+ return sha1_hash
+}
+
+
+
package registry
+
+import (
+ "crypto/tls"
+ "fmt"
+ "io"
+ "net/http"
+ "time"
+
+ "github.com/feast-dev/feast/go/protos/feast/core"
+ "github.com/rs/zerolog/log"
+ "google.golang.org/protobuf/proto"
+)
+
+type HttpRegistryStore struct {
+ project string
+ endpoint string
+ clientId string
+ client http.Client
+}
+
+// NotImplementedError represents an error for a function that is not yet implemented.
+type NotImplementedError struct {
+ FunctionName string
+}
+
+// Error implements the error interface for NotImplementedError.
+func (e *NotImplementedError) Error() string {
+ return fmt.Sprintf("Function '%s' not implemented", e.FunctionName)
+}
+
+func NewHttpRegistryStore(config *RegistryConfig, project string) (*HttpRegistryStore, error) {
+ tr := &http.Transport{
+ TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+ IdleConnTimeout: 60 * time.Second,
+ }
+
+ hrs := &HttpRegistryStore{
+ project: project,
+ endpoint: config.Path,
+ clientId: config.ClientId,
+ client: http.Client{
+ Transport: tr,
+ Timeout: 5 * time.Second,
+ },
+ }
+
+ if err := hrs.TestConnectivity(); err != nil {
+ return nil, err
+ }
+
+ return hrs, nil
+}
+
+func (hrs *HttpRegistryStore) TestConnectivity() error {
+ resp, err := hrs.client.Get(hrs.endpoint)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return fmt.Errorf("HTTP Registry connectivity check failed with status code: %d", resp.StatusCode)
+ }
+
+ return nil
+}
+
+func (r *HttpRegistryStore) makeHttpRequest(url string) (*http.Response, error) {
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ req.Header.Add("Accept", "application/x-protobuf")
+ req.Header.Add("Client-Id", r.clientId)
+
+ resp, err := r.client.Do(req)
+ if err != nil {
+ return nil, err
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("HTTP Error: %s", resp.Status)
+ }
+
+ return resp, nil
+}
+
+func (r *HttpRegistryStore) loadProtobufMessages(url string, messageProcessor func([]byte) error) error {
+ resp, err := r.makeHttpRequest(url)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ buffer, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+
+ if err := messageProcessor(buffer); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (r *HttpRegistryStore) loadEntities(registry *core.Registry) error {
+ url := fmt.Sprintf("%s/projects/%s/entities?allow_cache=true", r.endpoint, r.project)
+ return r.loadProtobufMessages(url, func(data []byte) error {
+ entity_list := &core.EntityList{}
+ if err := proto.Unmarshal(data, entity_list); err != nil {
+ return err
+ }
+ if len(entity_list.GetEntities()) == 0 {
+ log.Warn().Msg(fmt.Sprintf("Feature Registry has no associated Entities for project %s.", r.project))
+ }
+ registry.Entities = append(registry.Entities, entity_list.GetEntities()...)
+ return nil
+ })
+}
+
+func (r *HttpRegistryStore) loadDatasources(registry *core.Registry) error {
+ url := fmt.Sprintf("%s/projects/%s/data_sources?allow_cache=true", r.endpoint, r.project)
+ return r.loadProtobufMessages(url, func(data []byte) error {
+ data_source_list := &core.DataSourceList{}
+ if err := proto.Unmarshal(data, data_source_list); err != nil {
+ return err
+ }
+ if len(data_source_list.GetDatasources()) == 0 {
+ log.Warn().Msg(fmt.Sprintf("Feature Registry has no associated Datasources for project %s.", r.project))
+ }
+ registry.DataSources = append(registry.DataSources, data_source_list.GetDatasources()...)
+ return nil
+ })
+}
+
+func (r *HttpRegistryStore) loadFeatureViews(registry *core.Registry) error {
+ url := fmt.Sprintf("%s/projects/%s/feature_views?allow_cache=true", r.endpoint, r.project)
+ return r.loadProtobufMessages(url, func(data []byte) error {
+ feature_view_list := &core.FeatureViewList{}
+ if err := proto.Unmarshal(data, feature_view_list); err != nil {
+ return err
+ }
+ if len(feature_view_list.GetFeatureviews()) == 0 {
+ log.Warn().Msg(fmt.Sprintf("Feature Registry has no associated FeatureViews for project %s.", r.project))
+ }
+ registry.FeatureViews = append(registry.FeatureViews, feature_view_list.GetFeatureviews()...)
+ return nil
+ })
+}
+
+func (r *HttpRegistryStore) loadOnDemandFeatureViews(registry *core.Registry) error {
+ url := fmt.Sprintf("%s/projects/%s/on_demand_feature_views?allow_cache=true", r.endpoint, r.project)
+ return r.loadProtobufMessages(url, func(data []byte) error {
+ od_feature_view_list := &core.OnDemandFeatureViewList{}
+ if err := proto.Unmarshal(data, od_feature_view_list); err != nil {
+ return err
+ }
+ registry.OnDemandFeatureViews = append(registry.OnDemandFeatureViews, od_feature_view_list.GetOndemandfeatureviews()...)
+ return nil
+ })
+}
+
+func (r *HttpRegistryStore) loadFeatureServices(registry *core.Registry) error {
+ url := fmt.Sprintf("%s/projects/%s/feature_services?allow_cache=true", r.endpoint, r.project)
+ return r.loadProtobufMessages(url, func(data []byte) error {
+ feature_service_list := &core.FeatureServiceList{}
+ if err := proto.Unmarshal(data, feature_service_list); err != nil {
+ return err
+ }
+ registry.FeatureServices = append(registry.FeatureServices, feature_service_list.GetFeatureservices()...)
+ return nil
+ })
+}
+
+func (r *HttpRegistryStore) GetRegistryProto() (*core.Registry, error) {
+
+ registry := core.Registry{}
+
+ if err := r.loadEntities(®istry); err != nil {
+ return nil, err
+ }
+
+ if err := r.loadDatasources(®istry); err != nil {
+ return nil, err
+ }
+
+ if err := r.loadFeatureViews(®istry); err != nil {
+ return nil, err
+ }
+
+ if err := r.loadOnDemandFeatureViews(®istry); err != nil {
+ return nil, err
+ }
+
+ if err := r.loadFeatureServices(®istry); err != nil {
+ return nil, err
+ }
+
+ return ®istry, nil
+}
+
+func (r *HttpRegistryStore) UpdateRegistryProto(rp *core.Registry) error {
+ return &NotImplementedError{FunctionName: "UpdateRegistryProto"}
+}
+
+func (r *HttpRegistryStore) Teardown() error {
+ return &NotImplementedError{FunctionName: "Teardown"}
+}
+
+
+
package registry
+
+import (
+ "io/ioutil"
+ "os"
+ "path/filepath"
+
+ "github.com/google/uuid"
+ "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/types/known/timestamppb"
+
+ "github.com/feast-dev/feast/go/protos/feast/core"
+)
+
+// A FileRegistryStore is a file-based implementation of the RegistryStore interface.
+type FileRegistryStore struct {
+ filePath string
+}
+
+// NewFileRegistryStore creates a FileRegistryStore with the given configuration and infers
+// the file path from the repo path and registry path.
+func NewFileRegistryStore(config *RegistryConfig, repoPath string) *FileRegistryStore {
+ lr := FileRegistryStore{}
+ registryPath := config.Path
+ if filepath.IsAbs(registryPath) {
+ lr.filePath = registryPath
+ } else {
+ lr.filePath = filepath.Join(repoPath, registryPath)
+ }
+ return &lr
+}
+
+// GetRegistryProto reads and parses the registry proto from the file path.
+func (r *FileRegistryStore) GetRegistryProto() (*core.Registry, error) {
+ registry := &core.Registry{}
+ in, err := ioutil.ReadFile(r.filePath)
+ if err != nil {
+ return nil, err
+ }
+ if err := proto.Unmarshal(in, registry); err != nil {
+ return nil, err
+ }
+ return registry, nil
+}
+
+func (r *FileRegistryStore) UpdateRegistryProto(rp *core.Registry) error {
+ return r.writeRegistry(rp)
+}
+
+func (r *FileRegistryStore) Teardown() error {
+ return os.Remove(r.filePath)
+}
+
+func (r *FileRegistryStore) writeRegistry(rp *core.Registry) error {
+ rp.VersionId = uuid.New().String()
+ rp.LastUpdated = timestamppb.Now()
+ bytes, err := proto.Marshal(rp)
+ if err != nil {
+ return err
+ }
+ err = ioutil.WriteFile(r.filePath, bytes, 0644)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+
+
package registry
+
+import (
+ "errors"
+ "fmt"
+ "net/url"
+ "sync"
+ "time"
+
+ "github.com/feast-dev/feast/go/internal/feast/model"
+ "github.com/rs/zerolog/log"
+
+ "github.com/feast-dev/feast/go/protos/feast/core"
+)
+
+var REGISTRY_SCHEMA_VERSION string = "1"
+var REGISTRY_STORE_CLASS_FOR_SCHEME map[string]string = map[string]string{
+ "gs": "GCSRegistryStore",
+ "s3": "S3RegistryStore",
+ "file": "FileRegistryStore",
+ "http": "HttpRegistryStore",
+ "https": "HttpRegistryStore",
+ "": "FileRegistryStore",
+}
+
+/*
+ Store protos of FeatureView, FeatureService, Entity, OnDemandFeatureView
+ but return to user copies of non-proto versions of these objects
+*/
+
+type Registry struct {
+ project string
+ registryStore RegistryStore
+ cachedFeatureServices map[string]map[string]*core.FeatureService
+ cachedEntities map[string]map[string]*core.Entity
+ cachedFeatureViews map[string]map[string]*core.FeatureView
+ cachedStreamFeatureViews map[string]map[string]*core.StreamFeatureView
+ CachedOnDemandFeatureViews map[string]map[string]*core.OnDemandFeatureView
+ cachedRegistry *core.Registry
+ cachedRegistryProtoLastUpdated time.Time
+ cachedRegistryProtoTtl time.Duration
+ mu sync.RWMutex
+}
+
+func NewRegistry(registryConfig *RegistryConfig, repoPath string, project string) (*Registry, error) {
+ registryStoreType := registryConfig.RegistryStoreType
+ registryPath := registryConfig.Path
+ r := &Registry{
+ project: project,
+ cachedRegistryProtoTtl: time.Duration(registryConfig.CacheTtlSeconds) * time.Second,
+ }
+
+ if len(registryStoreType) == 0 {
+ registryStore, err := getRegistryStoreFromScheme(registryPath, registryConfig, repoPath, project)
+ if err != nil {
+ return nil, err
+ }
+ r.registryStore = registryStore
+ } else {
+ registryStore, err := getRegistryStoreFromType(registryStoreType, registryConfig, repoPath, project)
+ if err != nil {
+ return nil, err
+ }
+ r.registryStore = registryStore
+ }
+
+ return r, nil
+}
+
+func (r *Registry) InitializeRegistry() error {
+ _, err := r.getRegistryProto()
+ if err != nil {
+ if _, ok := r.registryStore.(*HttpRegistryStore); ok {
+ log.Error().Err(err).Msg("Registry Initialization Failed")
+ return err
+ }
+ registryProto := &core.Registry{RegistrySchemaVersion: REGISTRY_SCHEMA_VERSION}
+ r.registryStore.UpdateRegistryProto(registryProto)
+ }
+ go r.RefreshRegistryOnInterval()
+ return nil
+}
+
+func (r *Registry) RefreshRegistryOnInterval() {
+ ticker := time.NewTicker(r.cachedRegistryProtoTtl)
+ for ; true; <-ticker.C {
+ err := r.refresh()
+ if err != nil {
+ log.Error().Stack().Err(err).Msg("Registry refresh Failed")
+ }
+ }
+}
+
+func (r *Registry) refresh() error {
+ _, err := r.getRegistryProto()
+ return err
+}
+
+func (r *Registry) getRegistryProto() (*core.Registry, error) {
+ expired := r.cachedRegistry == nil || (r.cachedRegistryProtoTtl > 0 && time.Now().After(r.cachedRegistryProtoLastUpdated.Add(r.cachedRegistryProtoTtl)))
+ if !expired {
+ return r.cachedRegistry, nil
+ }
+ registryProto, err := r.registryStore.GetRegistryProto()
+ if err != nil {
+ return nil, err
+ }
+ r.load(registryProto)
+ return registryProto, nil
+}
+
+func (r *Registry) load(registry *core.Registry) {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ r.cachedRegistry = registry
+ r.cachedFeatureServices = make(map[string]map[string]*core.FeatureService)
+ r.cachedEntities = make(map[string]map[string]*core.Entity)
+ r.cachedFeatureViews = make(map[string]map[string]*core.FeatureView)
+ r.cachedStreamFeatureViews = make(map[string]map[string]*core.StreamFeatureView)
+ r.CachedOnDemandFeatureViews = make(map[string]map[string]*core.OnDemandFeatureView)
+ r.loadEntities(registry)
+ r.loadFeatureServices(registry)
+ r.loadFeatureViews(registry)
+ r.loadStreamFeatureViews(registry)
+ r.loadOnDemandFeatureViews(registry)
+ r.cachedRegistryProtoLastUpdated = time.Now()
+}
+
+func (r *Registry) loadEntities(registry *core.Registry) {
+ entities := registry.Entities
+ for _, entity := range entities {
+ if _, ok := r.cachedEntities[r.project]; !ok {
+ r.cachedEntities[r.project] = make(map[string]*core.Entity)
+ }
+ r.cachedEntities[r.project][entity.Spec.Name] = entity
+ }
+}
+
+func (r *Registry) loadFeatureServices(registry *core.Registry) {
+ featureServices := registry.FeatureServices
+ for _, featureService := range featureServices {
+ if _, ok := r.cachedFeatureServices[r.project]; !ok {
+ r.cachedFeatureServices[r.project] = make(map[string]*core.FeatureService)
+ }
+ r.cachedFeatureServices[r.project][featureService.Spec.Name] = featureService
+ }
+}
+
+func (r *Registry) loadFeatureViews(registry *core.Registry) {
+ featureViews := registry.FeatureViews
+ for _, featureView := range featureViews {
+ if _, ok := r.cachedFeatureViews[r.project]; !ok {
+ r.cachedFeatureViews[r.project] = make(map[string]*core.FeatureView)
+ }
+ r.cachedFeatureViews[r.project][featureView.Spec.Name] = featureView
+ }
+}
+
+func (r *Registry) loadStreamFeatureViews(registry *core.Registry) {
+ streamFeatureViews := registry.StreamFeatureViews
+ for _, streamFeatureView := range streamFeatureViews {
+ if _, ok := r.cachedStreamFeatureViews[r.project]; !ok {
+ r.cachedStreamFeatureViews[r.project] = make(map[string]*core.StreamFeatureView)
+ }
+ r.cachedStreamFeatureViews[r.project][streamFeatureView.Spec.Name] = streamFeatureView
+ }
+}
+
+func (r *Registry) loadOnDemandFeatureViews(registry *core.Registry) {
+ onDemandFeatureViews := registry.OnDemandFeatureViews
+ for _, onDemandFeatureView := range onDemandFeatureViews {
+ if _, ok := r.CachedOnDemandFeatureViews[r.project]; !ok {
+ r.CachedOnDemandFeatureViews[r.project] = make(map[string]*core.OnDemandFeatureView)
+ }
+ r.CachedOnDemandFeatureViews[r.project][onDemandFeatureView.Spec.Name] = onDemandFeatureView
+ }
+}
+
+/*
+ Look up Entities inside project
+ Returns empty list if project not found
+*/
+
+func (r *Registry) ListEntities(project string) ([]*model.Entity, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedEntities, ok := r.cachedEntities[project]; !ok {
+ return []*model.Entity{}, nil
+ } else {
+ entities := make([]*model.Entity, len(cachedEntities))
+ index := 0
+ for _, entityProto := range cachedEntities {
+ entities[index] = model.NewEntityFromProto(entityProto)
+ index += 1
+ }
+ return entities, nil
+ }
+}
+
+/*
+ Look up Feature Views inside project
+ Returns empty list if project not found
+*/
+
+func (r *Registry) ListFeatureViews(project string) ([]*model.FeatureView, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedFeatureViews, ok := r.cachedFeatureViews[project]; !ok {
+ return []*model.FeatureView{}, nil
+ } else {
+ featureViews := make([]*model.FeatureView, len(cachedFeatureViews))
+ index := 0
+ for _, featureViewProto := range cachedFeatureViews {
+ featureViews[index] = model.NewFeatureViewFromProto(featureViewProto)
+ index += 1
+ }
+ return featureViews, nil
+ }
+}
+
+/*
+ Look up Stream Feature Views inside project
+ Returns empty list if project not found
+*/
+
+func (r *Registry) ListStreamFeatureViews(project string) ([]*model.FeatureView, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedStreamFeatureViews, ok := r.cachedStreamFeatureViews[project]; !ok {
+ return []*model.FeatureView{}, nil
+ } else {
+ streamFeatureViews := make([]*model.FeatureView, len(cachedStreamFeatureViews))
+ index := 0
+ for _, streamFeatureViewProto := range cachedStreamFeatureViews {
+ streamFeatureViews[index] = model.NewFeatureViewFromStreamFeatureViewProto(streamFeatureViewProto)
+ index += 1
+ }
+ return streamFeatureViews, nil
+ }
+}
+
+/*
+ Look up Feature Services inside project
+ Returns empty list if project not found
+*/
+
+func (r *Registry) ListFeatureServices(project string) ([]*model.FeatureService, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedFeatureServices, ok := r.cachedFeatureServices[project]; !ok {
+ return []*model.FeatureService{}, nil
+ } else {
+ featureServices := make([]*model.FeatureService, len(cachedFeatureServices))
+ index := 0
+ for _, featureServiceProto := range cachedFeatureServices {
+ featureServices[index] = model.NewFeatureServiceFromProto(featureServiceProto)
+ index += 1
+ }
+ return featureServices, nil
+ }
+}
+
+/*
+ Look up On Demand Feature Views inside project
+ Returns empty list if project not found
+*/
+
+func (r *Registry) ListOnDemandFeatureViews(project string) ([]*model.OnDemandFeatureView, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedOnDemandFeatureViews, ok := r.CachedOnDemandFeatureViews[project]; !ok {
+ return []*model.OnDemandFeatureView{}, nil
+ } else {
+ onDemandFeatureViews := make([]*model.OnDemandFeatureView, len(cachedOnDemandFeatureViews))
+ index := 0
+ for _, onDemandFeatureViewProto := range cachedOnDemandFeatureViews {
+ onDemandFeatureViews[index] = model.NewOnDemandFeatureViewFromProto(onDemandFeatureViewProto)
+ index += 1
+ }
+ return onDemandFeatureViews, nil
+ }
+}
+
+func (r *Registry) GetEntity(project, entityName string) (*model.Entity, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedEntities, ok := r.cachedEntities[project]; !ok {
+ return nil, fmt.Errorf("no cached entities found for project %s", project)
+ } else {
+ if entity, ok := cachedEntities[entityName]; !ok {
+ return nil, fmt.Errorf("no cached entity %s found for project %s", entityName, project)
+ } else {
+ return model.NewEntityFromProto(entity), nil
+ }
+ }
+}
+
+func (r *Registry) GetFeatureView(project, featureViewName string) (*model.FeatureView, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedFeatureViews, ok := r.cachedFeatureViews[project]; !ok {
+ return nil, fmt.Errorf("no cached feature views found for project %s", project)
+ } else {
+ if featureViewProto, ok := cachedFeatureViews[featureViewName]; !ok {
+ return nil, fmt.Errorf("no cached feature view %s found for project %s", featureViewName, project)
+ } else {
+ return model.NewFeatureViewFromProto(featureViewProto), nil
+ }
+ }
+}
+
+func (r *Registry) GetStreamFeatureView(project, streamFeatureViewName string) (*model.FeatureView, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedStreamFeatureViews, ok := r.cachedStreamFeatureViews[project]; !ok {
+ return nil, fmt.Errorf("no cached stream feature views found for project %s", project)
+ } else {
+ if streamFeatureViewProto, ok := cachedStreamFeatureViews[streamFeatureViewName]; !ok {
+ return nil, fmt.Errorf("no cached stream feature view %s found for project %s", streamFeatureViewName, project)
+ } else {
+ return model.NewFeatureViewFromStreamFeatureViewProto(streamFeatureViewProto), nil
+ }
+ }
+}
+
+func (r *Registry) GetFeatureService(project, featureServiceName string) (*model.FeatureService, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedFeatureServices, ok := r.cachedFeatureServices[project]; !ok {
+ return nil, fmt.Errorf("no cached feature services found for project %s", project)
+ } else {
+ if featureServiceProto, ok := cachedFeatureServices[featureServiceName]; !ok {
+ return nil, fmt.Errorf("no cached feature service %s found for project %s", featureServiceName, project)
+ } else {
+ return model.NewFeatureServiceFromProto(featureServiceProto), nil
+ }
+ }
+}
+
+func (r *Registry) GetOnDemandFeatureView(project, onDemandFeatureViewName string) (*model.OnDemandFeatureView, error) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+ if cachedOnDemandFeatureViews, ok := r.CachedOnDemandFeatureViews[project]; !ok {
+ return nil, fmt.Errorf("no cached on demand feature views found for project %s", project)
+ } else {
+ if onDemandFeatureViewProto, ok := cachedOnDemandFeatureViews[onDemandFeatureViewName]; !ok {
+ return nil, fmt.Errorf("no cached on demand feature view %s found for project %s", onDemandFeatureViewName, project)
+ } else {
+ return model.NewOnDemandFeatureViewFromProto(onDemandFeatureViewProto), nil
+ }
+ }
+}
+
+func getRegistryStoreFromScheme(registryPath string, registryConfig *RegistryConfig, repoPath string, project string) (RegistryStore, error) {
+ uri, err := url.Parse(registryPath)
+ if err != nil {
+ return nil, err
+ }
+ if registryStoreType, ok := REGISTRY_STORE_CLASS_FOR_SCHEME[uri.Scheme]; ok {
+ return getRegistryStoreFromType(registryStoreType, registryConfig, repoPath, project)
+ }
+ return nil, fmt.Errorf("registry path %s has unsupported scheme %s. Supported schemes are file, s3 and gs", registryPath, uri.Scheme)
+}
+
+func getRegistryStoreFromType(registryStoreType string, registryConfig *RegistryConfig, repoPath string, project string) (RegistryStore, error) {
+ switch registryStoreType {
+ case "FileRegistryStore":
+ return NewFileRegistryStore(registryConfig, repoPath), nil
+ case "HttpRegistryStore":
+ return NewHttpRegistryStore(registryConfig, project)
+ }
+ return nil, errors.New("only FileRegistryStore or HttpRegistryStore as a RegistryStore is supported at this moment")
+}
+
+
+
package registry
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+ "path/filepath"
+ "time"
+
+ "github.com/feast-dev/feast/go/internal/feast/server/logging"
+ "github.com/ghodss/yaml"
+)
+
+const (
+ defaultCacheTtlSeconds = int64(600)
+ defaultClientID = "Unknown"
+)
+
+type RepoConfig struct {
+ // Feast project name
+ Project string `json:"project"`
+ // Feast provider name
+ Provider string `json:"provider"`
+ // Path to the registry. Custom registry loaders are not yet supported
+ // Registry string `json:"registry"`
+ Registry interface{} `json:"registry"`
+ // Online store config
+ OnlineStore map[string]interface{} `json:"online_store"`
+ // Offline store config
+ OfflineStore map[string]interface{} `json:"offline_store"`
+ // Feature server config (currently unrelated to Go server)
+ FeatureServer map[string]interface{} `json:"feature_server"`
+ // Feature flags for experimental features
+ Flags map[string]interface{} `json:"flags"`
+ // RepoPath
+ RepoPath string `json:"repo_path"`
+ // EntityKeySerializationVersion
+ EntityKeySerializationVersion int64 `json:"entity_key_serialization_version"`
+}
+
+type RegistryConfig struct {
+ RegistryStoreType string `json:"registry_store_type"`
+ Path string `json:"path"`
+ ClientId string `json:"client_id" default:"Unknown"`
+ CacheTtlSeconds int64 `json:"cache_ttl_seconds" default:"600"`
+}
+
+// NewRepoConfigFromJSON converts a JSON string into a RepoConfig struct and also sets the repo path.
+func NewRepoConfigFromJSON(repoPath, configJSON string) (*RepoConfig, error) {
+ config := RepoConfig{}
+ if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
+ return nil, err
+ }
+ repoPath, err := filepath.Abs(repoPath)
+ if err != nil {
+ return nil, err
+ }
+ config.RepoPath = repoPath
+ return &config, nil
+}
+
+// NewRepoConfigFromFile reads the `feature_store.yaml` file in the repo path and converts it
+// into a RepoConfig struct.
+func NewRepoConfigFromFile(repoPath string) (*RepoConfig, error) {
+ data, err := os.ReadFile(filepath.Join(repoPath, "feature_store.yaml"))
+ if err != nil {
+ return nil, err
+ }
+ repoPath, err = filepath.Abs(repoPath)
+ if err != nil {
+ return nil, err
+ }
+
+ repoConfigWithEnv := os.ExpandEnv(string(data))
+
+ config := RepoConfig{}
+ if err = yaml.Unmarshal([]byte(repoConfigWithEnv), &config); err != nil {
+ return nil, err
+ }
+ config.RepoPath = repoPath
+ return &config, nil
+}
+
+func (r *RepoConfig) GetLoggingOptions() (*logging.LoggingOptions, error) {
+ loggingOptions := logging.LoggingOptions{}
+ if loggingOptionsMap, ok := r.FeatureServer["feature_logging"].(map[string]interface{}); ok {
+ loggingOptions = logging.DefaultOptions
+ for k, v := range loggingOptionsMap {
+ switch k {
+ case "queue_capacity":
+ if value, ok := v.(int); ok {
+ loggingOptions.ChannelCapacity = value
+ }
+ case "emit_timeout_micro_secs":
+ if value, ok := v.(int); ok {
+ loggingOptions.EmitTimeout = time.Duration(value) * time.Microsecond
+ }
+ case "write_to_disk_interval_secs":
+ if value, ok := v.(int); ok {
+ loggingOptions.WriteInterval = time.Duration(value) * time.Second
+ }
+ case "flush_interval_secs":
+ if value, ok := v.(int); ok {
+ loggingOptions.FlushInterval = time.Duration(value) * time.Second
+ }
+ }
+ }
+ }
+ return &loggingOptions, nil
+}
+
+func (r *RepoConfig) GetRegistryConfig() (*RegistryConfig, error) {
+ if registryConfigMap, ok := r.Registry.(map[string]interface{}); ok {
+ registryConfig := RegistryConfig{CacheTtlSeconds: defaultCacheTtlSeconds, ClientId: defaultClientID}
+ for k, v := range registryConfigMap {
+ switch k {
+ case "path":
+ if value, ok := v.(string); ok {
+ registryConfig.Path = value
+ }
+ case "registry_store_type":
+ if value, ok := v.(string); ok {
+ registryConfig.RegistryStoreType = value
+ }
+ case "client_id":
+ if value, ok := v.(string); ok {
+ registryConfig.ClientId = value
+ }
+ case "cache_ttl_seconds":
+ // cache_ttl_seconds defaulted to type float64. Ex: "cache_ttl_seconds": 60 in registryConfigMap
+ switch value := v.(type) {
+ case float64:
+ registryConfig.CacheTtlSeconds = int64(value)
+ case int:
+ registryConfig.CacheTtlSeconds = int64(value)
+ case int32:
+ registryConfig.CacheTtlSeconds = int64(value)
+ case int64:
+ registryConfig.CacheTtlSeconds = value
+ default:
+ return nil, fmt.Errorf("unexpected type %T for CacheTtlSeconds", v)
+ }
+ }
+ }
+ return ®istryConfig, nil
+ } else {
+ return &RegistryConfig{Path: r.Registry.(string), ClientId: defaultClientID, CacheTtlSeconds: defaultCacheTtlSeconds}, nil
+ }
+}
+
+
+
package server
+
+import (
+ "context"
+ "fmt"
+ "github.com/feast-dev/feast/go/internal/feast"
+ "github.com/feast-dev/feast/go/internal/feast/server/logging"
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ prototypes "github.com/feast-dev/feast/go/protos/feast/types"
+ "github.com/feast-dev/feast/go/types"
+ "github.com/google/uuid"
+ "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+)
+
+const feastServerVersion = "0.0.1"
+
+type grpcServingServiceServer struct {
+ fs *feast.FeatureStore
+ loggingService *logging.LoggingService
+ serving.UnimplementedServingServiceServer
+}
+
+func NewGrpcServingServiceServer(fs *feast.FeatureStore, loggingService *logging.LoggingService) *grpcServingServiceServer {
+ return &grpcServingServiceServer{fs: fs, loggingService: loggingService}
+}
+
+func (s *grpcServingServiceServer) GetFeastServingInfo(ctx context.Context, request *serving.GetFeastServingInfoRequest) (*serving.GetFeastServingInfoResponse, error) {
+ return &serving.GetFeastServingInfoResponse{
+ Version: feastServerVersion,
+ }, nil
+}
+
+// GetOnlineFeatures Returns an object containing the response to GetOnlineFeatures.
+// Metadata contains feature names that corresponds to the number of rows in response.Results.
+// Results contains values including the value of the feature, the event timestamp, and feature status in a columnar format.
+func (s *grpcServingServiceServer) GetOnlineFeatures(ctx context.Context, request *serving.GetOnlineFeaturesRequest) (*serving.GetOnlineFeaturesResponse, error) {
+
+ span, ctx := tracer.StartSpanFromContext(ctx, "getOnlineFeatures", tracer.ResourceName("ServingService/GetOnlineFeatures"))
+ defer span.Finish()
+
+ logSpanContext := LogWithSpanContext(span)
+
+ requestId := GenerateRequestId()
+ featuresOrService, err := s.fs.ParseFeatures(request.GetKind())
+
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error parsing feature service or feature list from request")
+ return nil, err
+ }
+
+ featureVectors, err := s.fs.GetOnlineFeatures(
+ ctx,
+ featuresOrService.FeaturesRefs,
+ featuresOrService.FeatureService,
+ request.GetEntities(),
+ request.GetRequestContext(),
+ request.GetFullFeatureNames())
+
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error getting online features")
+ return nil, err
+ }
+
+ resp := &serving.GetOnlineFeaturesResponse{
+ Results: make([]*serving.GetOnlineFeaturesResponse_FeatureVector, 0),
+ Metadata: &serving.GetOnlineFeaturesResponseMetadata{
+ FeatureNames: &serving.FeatureList{Val: make([]string, 0)},
+ },
+ }
+ // JoinKeys are currently part of the features as a value and the order that we add it to the resp MetaData
+ // Need to figure out a way to map the correct entities to the correct ordering
+ entityValuesMap := make(map[string][]*prototypes.Value, 0)
+ featureNames := make([]string, len(featureVectors))
+ for idx, vector := range featureVectors {
+ resp.Metadata.FeatureNames.Val = append(resp.Metadata.FeatureNames.Val, vector.Name)
+ featureNames[idx] = vector.Name
+ values, err := types.ArrowValuesToProtoValues(vector.Values)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error converting Arrow values to proto values")
+ return nil, err
+ }
+ if _, ok := request.Entities[vector.Name]; ok {
+ entityValuesMap[vector.Name] = values
+ }
+
+ resp.Results = append(resp.Results, &serving.GetOnlineFeaturesResponse_FeatureVector{
+ Values: values,
+ Statuses: vector.Statuses,
+ EventTimestamps: vector.Timestamps,
+ })
+ }
+
+ featureService := featuresOrService.FeatureService
+ if featureService != nil && featureService.LoggingConfig != nil && s.loggingService != nil {
+ logger, err := s.loggingService.GetOrCreateLogger(featureService)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error to instantiating logger for feature service: " + featuresOrService.FeatureService.Name)
+ fmt.Printf("Couldn't instantiate logger for feature service %s: %+v", featuresOrService.FeatureService.Name, err)
+ }
+
+ err = logger.Log(request.Entities, resp.Results[len(request.Entities):], resp.Metadata.FeatureNames.Val[len(request.Entities):], request.RequestContext, requestId)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error to logging to feature service: " + featuresOrService.FeatureService.Name)
+ fmt.Printf("LoggerImpl error[%s]: %+v", featuresOrService.FeatureService.Name, err)
+ }
+ }
+ return resp, nil
+}
+
+func GenerateRequestId() string {
+ id := uuid.New()
+ return id.String()
+}
+
+
+
package server
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "os"
+ "runtime"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/feast-dev/feast/go/internal/feast"
+ "github.com/feast-dev/feast/go/internal/feast/model"
+ "github.com/feast-dev/feast/go/internal/feast/onlineserving"
+ "github.com/feast-dev/feast/go/internal/feast/server/logging"
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ prototypes "github.com/feast-dev/feast/go/protos/feast/types"
+ "github.com/feast-dev/feast/go/types"
+ "github.com/rs/zerolog/log"
+ httptrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/net/http"
+ "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+)
+
+type httpServer struct {
+ fs *feast.FeatureStore
+ loggingService *logging.LoggingService
+ server *http.Server
+}
+
+// Some Feast types aren't supported during JSON conversion
+type repeatedValue struct {
+ stringVal []string
+ int32Val []int32
+ int64Val []int64
+ doubleVal []float64
+ boolVal []bool
+ stringListVal [][]string
+ int32ListVal [][]int32
+ int64ListVal [][]int64
+ doubleListVal [][]float64
+ boolListVal [][]bool
+}
+
+func (u *repeatedValue) UnmarshalJSON(data []byte) error {
+ isString := false
+ isDouble := false
+ isInt64 := false
+ isArray := false
+ openBraketCounter := 0
+ for _, b := range data {
+ if b == '"' {
+ isString = true
+ }
+ if b == '.' {
+ isDouble = true
+ }
+ if b >= '0' && b <= '9' {
+ isInt64 = true
+ }
+ if b == '[' {
+ openBraketCounter++
+ if openBraketCounter > 1 {
+ isArray = true
+ }
+ }
+ }
+ var err error
+ if !isArray {
+ if isString {
+ err = json.Unmarshal(data, &u.stringVal)
+ } else if isDouble {
+ err = json.Unmarshal(data, &u.doubleVal)
+ } else if isInt64 {
+ err = json.Unmarshal(data, &u.int64Val)
+ } else {
+ err = json.Unmarshal(data, &u.boolVal)
+ }
+ } else {
+ if isString {
+ err = json.Unmarshal(data, &u.stringListVal)
+ } else if isDouble {
+ err = json.Unmarshal(data, &u.doubleListVal)
+ } else if isInt64 {
+ err = json.Unmarshal(data, &u.int64ListVal)
+ } else {
+ err = json.Unmarshal(data, &u.boolListVal)
+ }
+ }
+ return err
+}
+
+func (u *repeatedValue) ToProto() *prototypes.RepeatedValue {
+ proto := new(prototypes.RepeatedValue)
+ if u.stringVal != nil {
+ for _, val := range u.stringVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_StringVal{StringVal: val}})
+ }
+ }
+ if u.int64Val != nil {
+ for _, val := range u.int64Val {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_Int64Val{Int64Val: val}})
+ }
+ }
+ if u.int32Val != nil {
+ for _, val := range u.int32Val {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_Int32Val{Int32Val: val}})
+ }
+ }
+ if u.doubleVal != nil {
+ for _, val := range u.doubleVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_DoubleVal{DoubleVal: val}})
+ }
+ }
+ if u.boolVal != nil {
+ for _, val := range u.boolVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_BoolVal{BoolVal: val}})
+ }
+ }
+ if u.stringListVal != nil {
+ for _, val := range u.stringListVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_StringListVal{StringListVal: &prototypes.StringList{Val: val}}})
+ }
+ }
+ if u.int32ListVal != nil {
+ for _, val := range u.int32ListVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_Int32ListVal{Int32ListVal: &prototypes.Int32List{Val: val}}})
+ }
+ }
+ if u.int64ListVal != nil {
+ for _, val := range u.int64ListVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_Int64ListVal{Int64ListVal: &prototypes.Int64List{Val: val}}})
+ }
+ }
+ if u.doubleListVal != nil {
+ for _, val := range u.doubleListVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_DoubleListVal{DoubleListVal: &prototypes.DoubleList{Val: val}}})
+ }
+ }
+ if u.boolListVal != nil {
+ for _, val := range u.boolListVal {
+ proto.Val = append(proto.Val, &prototypes.Value{Val: &prototypes.Value_BoolListVal{BoolListVal: &prototypes.BoolList{Val: val}}})
+ }
+ }
+ return proto
+}
+
+type getOnlineFeaturesRequest struct {
+ FeatureService *string `json:"feature_service"`
+ Features []string `json:"features"`
+ Entities map[string]repeatedValue `json:"entities"`
+ FullFeatureNames bool `json:"full_feature_names"`
+ RequestContext map[string]repeatedValue `json:"request_context"`
+}
+
+func NewHttpServer(fs *feast.FeatureStore, loggingService *logging.LoggingService) *httpServer {
+ return &httpServer{fs: fs, loggingService: loggingService}
+}
+
+/*
+*
+Used to align a field specified in the request with its defined schema type.
+*/
+func typecastToFieldSchemaType(val *repeatedValue, fieldType prototypes.ValueType_Enum) {
+ if val.int64Val != nil {
+ if fieldType == prototypes.ValueType_INT32 {
+ for _, v := range val.int64Val {
+ val.int32Val = append(val.int32Val, int32(v))
+ }
+ val.int64Val = nil
+ }
+ }
+}
+
+func (s *httpServer) getOnlineFeatures(w http.ResponseWriter, r *http.Request) {
+ var err error
+
+ span, ctx := tracer.StartSpanFromContext(r.Context(), "getOnlineFeatures", tracer.ResourceName("/get-online-features"))
+ defer span.Finish(tracer.WithError(err))
+
+ logSpanContext := LogWithSpanContext(span)
+
+ if r.Method != "POST" {
+ http.NotFound(w, r)
+ return
+ }
+
+ statusQuery := r.URL.Query().Get("status")
+
+ status := false
+ if statusQuery != "" {
+ status, err = strconv.ParseBool(statusQuery)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error parsing status query parameter")
+ writeJSONError(w, fmt.Errorf("Error parsing status query parameter: %+v", err), http.StatusBadRequest)
+ return
+ }
+ }
+
+ decoder := json.NewDecoder(r.Body)
+ var request getOnlineFeaturesRequest
+ err = decoder.Decode(&request)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error decoding JSON request data")
+ writeJSONError(w, fmt.Errorf("Error decoding JSON request data: %+v", err), http.StatusInternalServerError)
+ return
+ }
+ var featureService *model.FeatureService
+ var entitiesProto = make(map[string]*prototypes.RepeatedValue)
+ var requestContextProto = make(map[string]*prototypes.RepeatedValue)
+ var odfVList = make([]*model.OnDemandFeatureView, 0)
+ var requestSources = make(map[string]prototypes.ValueType_Enum)
+
+ if request.FeatureService != nil && *request.FeatureService != "" {
+ featureService, err = s.fs.GetFeatureService(*request.FeatureService)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error getting feature service from registry")
+ writeJSONError(w, fmt.Errorf("Error getting feature service from registry: %+v", err), http.StatusInternalServerError)
+ return
+ }
+ for _, fv := range featureService.Projections {
+ odfv, _ := s.fs.GetOnDemandFeatureView(fv.Name)
+ if odfv != nil {
+ odfVList = append(odfVList, odfv)
+ }
+ }
+ } else if len(request.Features) > 0 {
+ log.Info().Msgf("request.Features %v", request.Features)
+ for _, featureName := range request.Features {
+ _, _, err := onlineserving.ParseFeatureReference(featureName)
+ if err != nil {
+ logSpanContext.Error().Err(err)
+ writeJSONError(w, fmt.Errorf("Error parsing feature reference %s", featureName), http.StatusBadRequest)
+ return
+ }
+ fv, odfv, _ := s.fs.ListAllViews()
+ if _, ok1 := odfv[featureName]; ok1 {
+ odfVList = append(odfVList, odfv[featureName])
+ } else if _, ok1 := fv[featureName]; !ok1 {
+ logSpanContext.Error().Msg("Feature View not found")
+ writeJSONError(w, fmt.Errorf("Feature View %s not found", featureName), http.StatusInternalServerError)
+ return
+ }
+ }
+ } else {
+ logSpanContext.Error().Msg("No Feature Views or Feature Services specified in the request")
+ writeJSONError(w, errors.New("No Feature Views or Feature Services specified in the request"), http.StatusBadRequest)
+ return
+ }
+ if odfVList != nil {
+ requestSources, _ = s.fs.GetRequestSources(odfVList)
+ }
+ if len(request.Entities) > 0 {
+ var entityType prototypes.ValueType_Enum
+ for key, value := range request.Entities {
+ entity, err := s.fs.GetEntity(key, false)
+ if err != nil {
+ if requestSources == nil {
+ logSpanContext.Error().Msgf("Entity %s not found ", key)
+ writeJSONError(w, fmt.Errorf("Entity %s not found ", key), http.StatusNotFound)
+ return
+ }
+ requestSourceType, ok := requestSources[key]
+ if !ok {
+ logSpanContext.Error().Msgf("Entity nor Request Source of name %s not found ", key)
+ writeJSONError(w, fmt.Errorf("Entity nor Request Source of name %s not found ", key), http.StatusNotFound)
+ return
+ }
+ entityType = requestSourceType
+ } else {
+ entityType = entity.ValueType
+ }
+ typecastToFieldSchemaType(&value, entityType)
+ entitiesProto[key] = value.ToProto()
+ }
+ }
+ if request.RequestContext != nil && len(request.RequestContext) > 0 {
+ for key, value := range request.RequestContext {
+ requestSourceType, ok := requestSources[key]
+ if !ok {
+ logSpanContext.Error().Msgf("Request Source %s not found ", key)
+ writeJSONError(w, fmt.Errorf("Request Source %s not found ", key), http.StatusNotFound)
+ return
+ }
+ typecastToFieldSchemaType(&value, requestSourceType)
+ requestContextProto[key] = value.ToProto()
+ }
+ }
+
+ featureVectors, err := s.fs.GetOnlineFeatures(
+ ctx,
+ request.Features,
+ featureService,
+ entitiesProto,
+ requestContextProto,
+ request.FullFeatureNames)
+
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error getting feature vector")
+ writeJSONError(w, fmt.Errorf("Error getting feature vector: %+v", err), http.StatusInternalServerError)
+ return
+ }
+
+ var featureNames []string
+ var results []map[string]interface{}
+ for _, vector := range featureVectors {
+ featureNames = append(featureNames, vector.Name)
+ result := make(map[string]interface{})
+ if status {
+ var statuses []string
+ for _, status := range vector.Statuses {
+ statuses = append(statuses, status.String())
+ }
+ var timestamps []string
+ for _, timestamp := range vector.Timestamps {
+ timestamps = append(timestamps, timestamp.AsTime().Format(time.RFC3339))
+ }
+
+ result["statuses"] = statuses
+ result["event_timestamps"] = timestamps
+ }
+ // Note, that vector.Values is an Arrow Array, but this type implements JSON Marshaller.
+ // So, it's not necessary to pre-process it in any way.
+ result["values"] = vector.Values
+
+ results = append(results, result)
+ }
+
+ response := map[string]interface{}{
+ "metadata": map[string]interface{}{
+ "feature_names": featureNames,
+ },
+ "results": results,
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+
+ err = json.NewEncoder(w).Encode(response)
+
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Error encoding response")
+ writeJSONError(w, fmt.Errorf("Error encoding response: %+v", err), http.StatusInternalServerError)
+ return
+ }
+
+ if featureService != nil && featureService.LoggingConfig != nil && s.loggingService != nil {
+ logger, err := s.loggingService.GetOrCreateLogger(featureService)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msgf("Couldn't instantiate logger for feature service %s", featureService.Name)
+ writeJSONError(w, fmt.Errorf("Couldn't instantiate logger for feature service %s: %+v", featureService.Name, err), http.StatusInternalServerError)
+ return
+ }
+
+ requestId := GenerateRequestId()
+
+ // Note: we're converting arrow to proto for feature logging. In the future we should
+ // base feature logging on arrow so that we don't have to do this extra conversion.
+ var featureVectorProtos []*serving.GetOnlineFeaturesResponse_FeatureVector
+ for _, vector := range featureVectors[len(request.Entities):] {
+ values, err := types.ArrowValuesToProtoValues(vector.Values)
+ if err != nil {
+ logSpanContext.Error().Err(err).Msg("Couldn't convert arrow values into protobuf")
+ writeJSONError(w, fmt.Errorf("Couldn't convert arrow values into protobuf: %+v", err), http.StatusInternalServerError)
+ return
+ }
+ featureVectorProtos = append(featureVectorProtos, &serving.GetOnlineFeaturesResponse_FeatureVector{
+ Values: values,
+ Statuses: vector.Statuses,
+ EventTimestamps: vector.Timestamps,
+ })
+ }
+
+ err = logger.Log(entitiesProto, featureVectorProtos, featureNames[len(request.Entities):], requestContextProto, requestId)
+ if err != nil {
+ writeJSONError(w, fmt.Errorf("LoggerImpl error[%s]: %+v", featureService.Name, err), http.StatusInternalServerError)
+ return
+ }
+ }
+
+ go releaseCGOMemory(featureVectors)
+}
+
+func releaseCGOMemory(featureVectors []*onlineserving.FeatureVector) {
+ for _, vector := range featureVectors {
+ vector.Values.Release()
+ }
+}
+
+func logStackTrace() {
+ // Start with a small buffer and grow it until the full stack trace fits.
+ buf := make([]byte, 1024)
+ for {
+ stackSize := runtime.Stack(buf, false)
+ if stackSize < len(buf) {
+ // The stack trace fits in the buffer, so we can log it now.
+ log.Error().Str("stack_trace", string(buf[:stackSize])).Msg("")
+ return
+ }
+ // The stack trace doesn't fit in the buffer, so we need to grow the buffer and try again.
+ buf = make([]byte, 2*len(buf))
+ }
+}
+
+func writeJSONError(w http.ResponseWriter, err error, statusCode int) {
+ errMap := map[string]interface{}{
+ "error": fmt.Sprintf("%+v", err),
+ "status_code": statusCode,
+ }
+ errJSON, _ := json.Marshal(errMap)
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(statusCode)
+ w.Write(errJSON)
+}
+
+func recoverMiddleware(next http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ defer func() {
+ if r := recover(); r != nil {
+ log.Error().Err(fmt.Errorf("Panic recovered: %v", r)).Msg("A panic occurred in the server")
+ // Log the stack trace
+ logStackTrace()
+
+ writeJSONError(w, fmt.Errorf("Internal Server Error: %v", r), http.StatusInternalServerError)
+ }
+ }()
+ next.ServeHTTP(w, r)
+ })
+}
+
+func (s *httpServer) Serve(host string, port int) error {
+ if strings.ToLower(os.Getenv("ENABLE_DATADOG_TRACING")) == "true" {
+ tracer.Start(tracer.WithRuntimeMetrics())
+ defer tracer.Stop()
+ }
+ mux := httptrace.NewServeMux()
+ mux.Handle("/get-online-features", recoverMiddleware(http.HandlerFunc(s.getOnlineFeatures)))
+ mux.HandleFunc("/health", healthCheckHandler)
+ s.server = &http.Server{Addr: fmt.Sprintf("%s:%d", host, port), Handler: mux, ReadTimeout: 5 * time.Second, WriteTimeout: 10 * time.Second, IdleTimeout: 15 * time.Second}
+ err := s.server.ListenAndServe()
+ // Don't return the error if it's caused by graceful shutdown using Stop()
+ if err == http.ErrServerClosed {
+ return nil
+ }
+ log.Fatal().Stack().Err(err).Msg("Failed to start HTTP server")
+ return err
+}
+
+func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ fmt.Fprintf(w, "Healthy")
+}
+func (s *httpServer) Stop() error {
+ if s.server != nil {
+ return s.server.Shutdown(context.Background())
+ }
+ return nil
+}
+
+
+
package logging
+
+import (
+ "fmt"
+
+ "github.com/feast-dev/feast/go/internal/feast/model"
+ "github.com/feast-dev/feast/go/protos/feast/types"
+)
+
+type FeatureServiceSchema struct {
+ JoinKeys []string
+ Features []string
+ RequestData []string
+
+ JoinKeysTypes map[string]types.ValueType_Enum
+ FeaturesTypes map[string]types.ValueType_Enum
+ RequestDataTypes map[string]types.ValueType_Enum
+}
+
+func GenerateSchemaFromFeatureService(fs FeatureStore, featureServiceName string) (*FeatureServiceSchema, error) {
+ entityMap, fvMap, odFvMap, err := fs.GetFcosMap()
+ if err != nil {
+ return nil, err
+ }
+
+ featureService, err := fs.GetFeatureService(featureServiceName)
+ if err != nil {
+ return nil, err
+ }
+
+ return generateSchema(featureService, entityMap, fvMap, odFvMap)
+}
+
+func generateSchema(featureService *model.FeatureService, entityMap map[string]*model.Entity, fvMap map[string]*model.FeatureView, odFvMap map[string]*model.OnDemandFeatureView) (*FeatureServiceSchema, error) {
+ joinKeys := make([]string, 0)
+ features := make([]string, 0)
+ requestData := make([]string, 0)
+
+ joinKeysSet := make(map[string]interface{})
+
+ entityJoinKeyToType := make(map[string]types.ValueType_Enum)
+ allFeatureTypes := make(map[string]types.ValueType_Enum)
+ requestDataTypes := make(map[string]types.ValueType_Enum)
+
+ for _, featureProjection := range featureService.Projections {
+ // Create copies of FeatureView that may contains the same *FeatureView but
+ // each differentiated by a *FeatureViewProjection
+ featureViewName := featureProjection.Name
+ if fv, ok := fvMap[featureViewName]; ok {
+ for _, f := range featureProjection.Features {
+ fullFeatureName := getFullFeatureName(featureProjection.NameToUse(), f.Name)
+ features = append(features, fullFeatureName)
+ allFeatureTypes[fullFeatureName] = f.Dtype
+ }
+ for _, entityColumn := range fv.EntityColumns {
+ var joinKey string
+ if joinKeyAlias, ok := featureProjection.JoinKeyMap[entityColumn.Name]; ok {
+ joinKey = joinKeyAlias
+ } else {
+ joinKey = entityColumn.Name
+ }
+
+ if _, ok := joinKeysSet[joinKey]; !ok {
+ joinKeys = append(joinKeys, joinKey)
+ }
+
+ joinKeysSet[joinKey] = nil
+ entityJoinKeyToType[joinKey] = entityColumn.Dtype
+ }
+ } else if odFv, ok := odFvMap[featureViewName]; ok {
+ for _, f := range featureProjection.Features {
+ fullFeatureName := getFullFeatureName(featureProjection.NameToUse(), f.Name)
+ features = append(features, fullFeatureName)
+ allFeatureTypes[fullFeatureName] = f.Dtype
+ }
+ for paramName, paramType := range odFv.GetRequestDataSchema() {
+ requestData = append(requestData, paramName)
+ requestDataTypes[paramName] = paramType
+ }
+ } else {
+ return nil, fmt.Errorf("no such feature view %s found (referenced from feature service %s)",
+ featureViewName, featureService.Name)
+ }
+ }
+
+ schema := &FeatureServiceSchema{
+ JoinKeys: joinKeys,
+ Features: features,
+ RequestData: requestData,
+
+ JoinKeysTypes: entityJoinKeyToType,
+ FeaturesTypes: allFeatureTypes,
+ RequestDataTypes: requestDataTypes,
+ }
+ return schema, nil
+}
+
+
+
package logging
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+
+ "github.com/pkg/errors"
+
+ "github.com/apache/arrow/go/v8/arrow"
+ "github.com/google/uuid"
+
+ "github.com/apache/arrow/go/v8/arrow/array"
+ "github.com/apache/arrow/go/v8/parquet"
+ "github.com/apache/arrow/go/v8/parquet/pqarrow"
+)
+
+type FileLogSink struct {
+ path string
+}
+
+// FileLogSink is currently only used for testing. It will be instantiated during go unit tests to log to file
+// and the parquet files will be cleaned up after the test is run.
+func NewFileLogSink(path string) (*FileLogSink, error) {
+ if path == "" {
+ return nil, errors.New("need path for file log sink")
+ }
+
+ absPath, err := filepath.Abs(path)
+ if err != nil {
+ return nil, err
+ }
+ return &FileLogSink{path: absPath}, nil
+}
+
+func (s *FileLogSink) Write(records []arrow.Record) error {
+ fileName, _ := uuid.NewUUID()
+
+ var writer io.Writer
+ writer, err := os.Create(filepath.Join(s.path, fmt.Sprintf("%s.parquet", fileName.String())))
+ if err != nil {
+ return err
+ }
+ table := array.NewTableFromRecords(records[0].Schema(), records)
+
+ props := parquet.NewWriterProperties(parquet.WithDictionaryDefault(false))
+ arrProps := pqarrow.DefaultWriterProps()
+ return pqarrow.WriteTable(table, writer, 100, props, arrProps)
+}
+
+func (s *FileLogSink) Flush(featureServiceName string) error {
+ // files are already flushed during Write
+ return nil
+}
+
+
+
package logging
+
+import (
+ "fmt"
+ "log"
+ "math/rand"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/apache/arrow/go/v8/arrow"
+ "github.com/pkg/errors"
+ "google.golang.org/protobuf/types/known/timestamppb"
+
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ "github.com/feast-dev/feast/go/protos/feast/types"
+)
+
+type Log struct {
+ // Example: val{int64_val: 5017}, val{int64_val: 1003}
+ EntityValue []*types.Value
+ RequestData []*types.Value
+
+ FeatureValues []*types.Value
+ FeatureStatuses []serving.FieldStatus
+ EventTimestamps []*timestamppb.Timestamp
+
+ RequestId string
+ LogTimestamp time.Time
+}
+
+type LogSink interface {
+ // Write is used to unload logs from memory buffer.
+ // Logs are not guaranteed to be flushed to sink on this point.
+ // The data can just be written to local disk (depending on implementation).
+ Write(data []arrow.Record) error
+
+ // Flush actually send data to a sink.
+ // We want to control amount to interaction with sink, since it could be a costly operation.
+ // Also, some sinks like BigQuery might have quotes and physically limit amount of write requests per day.
+ Flush(featureServiceName string) error
+}
+
+type Logger interface {
+ Log(joinKeyToEntityValues map[string]*types.RepeatedValue, featureVectors []*serving.GetOnlineFeaturesResponse_FeatureVector, featureNames []string, requestData map[string]*types.RepeatedValue, requestId string) error
+}
+
+type LoggerImpl struct {
+ featureServiceName string
+
+ buffer *MemoryBuffer
+ schema *FeatureServiceSchema
+
+ logCh chan *Log
+ signalCh chan interface{}
+
+ sink LogSink
+ config LoggerConfig
+
+ isStopped bool
+ cond *sync.Cond
+}
+
+type LoggerConfig struct {
+ LoggingOptions
+
+ SampleRate float32
+}
+
+func NewLoggerConfig(sampleRate float32, opts LoggingOptions) LoggerConfig {
+ return LoggerConfig{
+ LoggingOptions: opts,
+ SampleRate: sampleRate,
+ }
+}
+
+func NewLogger(schema *FeatureServiceSchema, featureServiceName string, sink LogSink, config LoggerConfig) (*LoggerImpl, error) {
+ buffer, err := NewMemoryBuffer(schema)
+ if err != nil {
+ return nil, err
+ }
+ logger := &LoggerImpl{
+ featureServiceName: featureServiceName,
+
+ logCh: make(chan *Log, config.ChannelCapacity),
+ signalCh: make(chan interface{}, 2),
+ sink: sink,
+
+ buffer: buffer,
+ schema: schema,
+ config: config,
+
+ isStopped: false,
+ cond: sync.NewCond(&sync.Mutex{}),
+ }
+
+ logger.startLoggerLoop()
+ return logger, nil
+}
+
+func (l *LoggerImpl) EmitLog(log *Log) error {
+ select {
+ case l.logCh <- log:
+ return nil
+ case <-time.After(l.config.EmitTimeout):
+ return fmt.Errorf("could not add to log channel with capacity %d. Operation timed out. Current log channel length is %d", cap(l.logCh), len(l.logCh))
+ }
+}
+
+func (l *LoggerImpl) startLoggerLoop() {
+ go func() {
+ for {
+ if err := l.loggerLoop(); err != nil {
+ log.Printf("LoggerImpl[%s] recovered from panic: %+v", l.featureServiceName, err)
+
+ // Sleep for a couple of milliseconds to avoid CPU load from a potential infinite panic-recovery loop
+ time.Sleep(5 * time.Millisecond)
+ continue // try again
+ }
+
+ // graceful stop
+ return
+ }
+ }()
+}
+
+// Select that either ingests new logs that are added to the logging channel, one at a time to add
+// to the in-memory buffer or flushes all of them synchronously to the OfflineStorage on a time interval.
+func (l *LoggerImpl) loggerLoop() (lErr error) {
+ defer func() {
+ // Recover from panic in the logger loop, so that it doesn't bring down the entire feature server
+ if r := recover(); r != nil {
+ rErr, ok := r.(error)
+ if !ok {
+ rErr = fmt.Errorf("%v", r)
+ }
+ lErr = errors.WithStack(rErr)
+ }
+ }()
+
+ writeTicker := time.NewTicker(l.config.WriteInterval)
+ flushTicker := time.NewTicker(l.config.FlushInterval)
+
+ for {
+ shouldStop := false
+
+ select {
+ case <-l.signalCh:
+ err := l.buffer.writeBatch(l.sink)
+ if err != nil {
+ log.Printf("Log write failed: %+v", err)
+ }
+ err = l.sink.Flush(l.featureServiceName)
+ if err != nil {
+ log.Printf("Log flush failed: %+v", err)
+ }
+ shouldStop = true
+ case <-writeTicker.C:
+ err := l.buffer.writeBatch(l.sink)
+ if err != nil {
+ log.Printf("Log write failed: %+v", err)
+ }
+ case <-flushTicker.C:
+ err := l.sink.Flush(l.featureServiceName)
+ if err != nil {
+ log.Printf("Log flush failed: %+v", err)
+ }
+ case logItem := <-l.logCh:
+ err := l.buffer.Append(logItem)
+ if err != nil {
+ log.Printf("Append log failed: %+v", err)
+ }
+ }
+
+ if shouldStop {
+ break
+ }
+ }
+
+ writeTicker.Stop()
+ flushTicker.Stop()
+
+ // Notify all waiters for graceful stop
+ l.cond.L.Lock()
+ l.isStopped = true
+ l.cond.Broadcast()
+ l.cond.L.Unlock()
+ return nil
+}
+
+// Stop the loop goroutine gracefully
+func (l *LoggerImpl) Stop() {
+ select {
+ case l.signalCh <- nil:
+ default:
+ }
+}
+
+func (l *LoggerImpl) WaitUntilStopped() {
+ l.cond.L.Lock()
+ defer l.cond.L.Unlock()
+ for !l.isStopped {
+ l.cond.Wait()
+ }
+}
+
+func getFullFeatureName(featureViewName string, featureName string) string {
+ return fmt.Sprintf("%s__%s", featureViewName, featureName)
+}
+
+func (l *LoggerImpl) Log(joinKeyToEntityValues map[string]*types.RepeatedValue, featureVectors []*serving.GetOnlineFeaturesResponse_FeatureVector, featureNames []string, requestData map[string]*types.RepeatedValue, requestId string) error {
+ if len(featureVectors) == 0 {
+ return nil
+ }
+
+ if rand.Float32() > l.config.SampleRate {
+ return nil
+ }
+
+ numFeatures := len(l.schema.Features)
+ // Should be equivalent to how many entities there are(each feature row has (entity) number of features)
+ numRows := len(featureVectors[0].Values)
+
+ featureNameToVectorIdx := make(map[string]int)
+ for idx, name := range featureNames {
+ featureNameToVectorIdx[name] = idx
+ }
+
+ for rowIdx := 0; rowIdx < numRows; rowIdx++ {
+ featureValues := make([]*types.Value, numFeatures)
+ featureStatuses := make([]serving.FieldStatus, numFeatures)
+ eventTimestamps := make([]*timestamppb.Timestamp, numFeatures)
+
+ for idx, featureName := range l.schema.Features {
+ featureIdx, ok := featureNameToVectorIdx[featureName]
+ if !ok {
+ featureNameParts := strings.Split(featureName, "__")
+ featureIdx, ok = featureNameToVectorIdx[featureNameParts[1]]
+ if !ok {
+ return errors.Errorf("Missing feature %s in log data", featureName)
+ }
+ }
+ featureValues[idx] = featureVectors[featureIdx].Values[rowIdx]
+ featureStatuses[idx] = featureVectors[featureIdx].Statuses[rowIdx]
+ eventTimestamps[idx] = featureVectors[featureIdx].EventTimestamps[rowIdx]
+ }
+
+ entityValues := make([]*types.Value, len(l.schema.JoinKeys))
+ for idx, joinKey := range l.schema.JoinKeys {
+ rows, ok := joinKeyToEntityValues[joinKey]
+ if !ok {
+ return errors.Errorf("Missing join key %s in log data", joinKey)
+ }
+ entityValues[idx] = rows.Val[rowIdx]
+ }
+
+ requestDataValues := make([]*types.Value, len(l.schema.RequestData))
+ for idx, requestParam := range l.schema.RequestData {
+ rows, ok := requestData[requestParam]
+ if !ok {
+ return errors.Errorf("Missing request parameter %s in log data", requestParam)
+ }
+ requestDataValues[idx] = rows.Val[rowIdx]
+ }
+
+ newLog := Log{
+ EntityValue: entityValues,
+ RequestData: requestDataValues,
+
+ FeatureValues: featureValues,
+ FeatureStatuses: featureStatuses,
+ EventTimestamps: eventTimestamps,
+
+ RequestId: requestId,
+ LogTimestamp: time.Now().UTC(),
+ }
+ err := l.EmitLog(&newLog)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+type DummyLoggerImpl struct{}
+
+func (l *DummyLoggerImpl) Log(joinKeyToEntityValues map[string]*types.RepeatedValue, featureVectors []*serving.GetOnlineFeaturesResponse_FeatureVector, featureNames []string, requestData map[string]*types.RepeatedValue, requestId string) error {
+ return nil
+}
+
+
+
package logging
+
+import (
+ "fmt"
+
+ "github.com/apache/arrow/go/v8/arrow"
+ "github.com/apache/arrow/go/v8/arrow/array"
+ "github.com/apache/arrow/go/v8/arrow/memory"
+
+ "github.com/feast-dev/feast/go/protos/feast/types"
+ gotypes "github.com/feast-dev/feast/go/types"
+)
+
+type MemoryBuffer struct {
+ logs []*Log
+ schema *FeatureServiceSchema
+
+ arrowSchema *arrow.Schema
+ records []arrow.Record
+}
+
+const (
+ LOG_TIMESTAMP_FIELD = "__log_timestamp"
+ LOG_DATE_FIELD = "__log_date"
+ LOG_REQUEST_ID_FIELD = "__request_id"
+ RECORD_SIZE = 1000
+)
+
+func NewMemoryBuffer(schema *FeatureServiceSchema) (*MemoryBuffer, error) {
+ arrowSchema, err := getArrowSchema(schema)
+ if err != nil {
+ return nil, err
+ }
+ return &MemoryBuffer{
+ logs: make([]*Log, 0),
+ records: make([]arrow.Record, 0),
+ schema: schema,
+ arrowSchema: arrowSchema,
+ }, nil
+}
+
+// Acquires the logging schema from the feature service, converts the memory buffer array of rows of logs and flushes
+// them to the offline storage.
+func (b *MemoryBuffer) writeBatch(sink LogSink) error {
+ if len(b.logs) > 0 {
+ err := b.Compact()
+ if err != nil {
+ return err
+ }
+ }
+
+ if len(b.records) == 0 {
+ return nil
+ }
+
+ err := sink.Write(b.records)
+ if err != nil {
+ return err
+ }
+
+ b.records = b.records[:0]
+ return nil
+}
+
+func (b *MemoryBuffer) Append(log *Log) error {
+ b.logs = append(b.logs, log)
+
+ if len(b.logs) == RECORD_SIZE {
+ return b.Compact()
+ }
+
+ return nil
+}
+
+func (b *MemoryBuffer) Compact() error {
+ rec, err := b.convertToArrowRecord()
+ if err != nil {
+ return err
+ }
+ b.records = append(b.records, rec)
+ b.logs = b.logs[:0]
+ return nil
+}
+
+func getArrowSchema(schema *FeatureServiceSchema) (*arrow.Schema, error) {
+ fields := make([]arrow.Field, 0)
+
+ for _, joinKey := range schema.JoinKeys {
+ arrowType, err := gotypes.ValueTypeEnumToArrowType(schema.JoinKeysTypes[joinKey])
+ if err != nil {
+ return nil, err
+ }
+
+ fields = append(fields, arrow.Field{Name: joinKey, Type: arrowType})
+ }
+
+ for _, requestParam := range schema.RequestData {
+ arrowType, err := gotypes.ValueTypeEnumToArrowType(schema.RequestDataTypes[requestParam])
+ if err != nil {
+ return nil, err
+ }
+
+ fields = append(fields, arrow.Field{Name: requestParam, Type: arrowType})
+ }
+
+ for _, featureName := range schema.Features {
+ arrowType, err := gotypes.ValueTypeEnumToArrowType(schema.FeaturesTypes[featureName])
+ if err != nil {
+ return nil, err
+ }
+
+ fields = append(fields, arrow.Field{Name: featureName, Type: arrowType})
+ fields = append(fields, arrow.Field{
+ Name: fmt.Sprintf("%s__timestamp", featureName),
+ Type: arrow.FixedWidthTypes.Timestamp_s})
+ fields = append(fields, arrow.Field{
+ Name: fmt.Sprintf("%s__status", featureName),
+ Type: arrow.PrimitiveTypes.Int32})
+ }
+
+ fields = append(fields, arrow.Field{Name: LOG_TIMESTAMP_FIELD, Type: arrow.FixedWidthTypes.Timestamp_us})
+ fields = append(fields, arrow.Field{Name: LOG_DATE_FIELD, Type: arrow.FixedWidthTypes.Date32})
+ fields = append(fields, arrow.Field{Name: LOG_REQUEST_ID_FIELD, Type: arrow.BinaryTypes.String})
+
+ return arrow.NewSchema(fields, nil), nil
+}
+
+// convertToArrowRecord Takes memory buffer of logs in array row and converts them to columnar with generated fcoschema generated by GetFcoSchema
+// and writes them to arrow table.
+// Returns arrow table that contains all of the logs in columnar format.
+func (b *MemoryBuffer) convertToArrowRecord() (arrow.Record, error) {
+ arrowMemory := memory.NewGoAllocator()
+ numRows := len(b.logs)
+
+ columns := make(map[string][]*types.Value)
+ fieldNameToIdx := make(map[string]int)
+ for idx, field := range b.arrowSchema.Fields() {
+ fieldNameToIdx[field.Name] = idx
+ }
+
+ builder := array.NewRecordBuilder(arrowMemory, b.arrowSchema)
+ defer builder.Release()
+
+ builder.Reserve(numRows)
+
+ for rowIdx, logRow := range b.logs {
+ for colIdx, joinKey := range b.schema.JoinKeys {
+ if _, ok := columns[joinKey]; !ok {
+ columns[joinKey] = make([]*types.Value, numRows)
+ }
+ columns[joinKey][rowIdx] = logRow.EntityValue[colIdx]
+ }
+ for colIdx, requestParam := range b.schema.RequestData {
+ if _, ok := columns[requestParam]; !ok {
+ columns[requestParam] = make([]*types.Value, numRows)
+ }
+ columns[requestParam][rowIdx] = logRow.RequestData[colIdx]
+ }
+ for colIdx, featureName := range b.schema.Features {
+ if _, ok := columns[featureName]; !ok {
+ columns[featureName] = make([]*types.Value, numRows)
+ }
+ columns[featureName][rowIdx] = logRow.FeatureValues[colIdx]
+
+ timestamp := arrow.Timestamp(logRow.EventTimestamps[colIdx].GetSeconds())
+ timestampFieldIdx := fieldNameToIdx[fmt.Sprintf("%s__timestamp", featureName)]
+ statusFieldIdx := fieldNameToIdx[fmt.Sprintf("%s__status", featureName)]
+
+ builder.Field(timestampFieldIdx).(*array.TimestampBuilder).UnsafeAppend(timestamp)
+ builder.Field(statusFieldIdx).(*array.Int32Builder).UnsafeAppend(int32(logRow.FeatureStatuses[colIdx]))
+ }
+
+ logTimestamp := arrow.Timestamp(logRow.LogTimestamp.UnixMicro())
+ logDate := arrow.Date32FromTime(logRow.LogTimestamp)
+
+ builder.Field(fieldNameToIdx[LOG_TIMESTAMP_FIELD]).(*array.TimestampBuilder).UnsafeAppend(logTimestamp)
+ builder.Field(fieldNameToIdx[LOG_DATE_FIELD]).(*array.Date32Builder).UnsafeAppend(logDate)
+ builder.Field(fieldNameToIdx[LOG_REQUEST_ID_FIELD]).(*array.StringBuilder).Append(logRow.RequestId)
+ }
+
+ for columnName, protoArray := range columns {
+ fieldIdx := fieldNameToIdx[columnName]
+ err := gotypes.CopyProtoValuesToArrowArray(builder.Field(fieldIdx), protoArray)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return builder.NewRecord(), nil
+}
+
+
+
package logging
+
+import (
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "os"
+ "path/filepath"
+
+ "github.com/apache/arrow/go/v8/arrow"
+ "github.com/apache/arrow/go/v8/arrow/array"
+ "github.com/apache/arrow/go/v8/parquet"
+ "github.com/apache/arrow/go/v8/parquet/pqarrow"
+ "github.com/google/uuid"
+)
+
+type OfflineStoreWriteCallback func(featureServiceName, datasetDir string) string
+
+type OfflineStoreSink struct {
+ datasetDir string
+ writeCallback OfflineStoreWriteCallback
+}
+
+func NewOfflineStoreSink(writeCallback OfflineStoreWriteCallback) (*OfflineStoreSink, error) {
+ return &OfflineStoreSink{
+ datasetDir: "",
+ writeCallback: writeCallback,
+ }, nil
+}
+
+func (s *OfflineStoreSink) getOrCreateDatasetDir() (string, error) {
+ if s.datasetDir != "" {
+ return s.datasetDir, nil
+ }
+ dir, err := ioutil.TempDir("", "*")
+ if err != nil {
+ return "", err
+ }
+ s.datasetDir = dir
+ return s.datasetDir, nil
+}
+
+func (s *OfflineStoreSink) Write(records []arrow.Record) error {
+ fileName, _ := uuid.NewUUID()
+ datasetDir, err := s.getOrCreateDatasetDir()
+ if err != nil {
+ return err
+ }
+
+ var writer io.Writer
+ writer, err = os.Create(filepath.Join(datasetDir, fmt.Sprintf("%s.parquet", fileName.String())))
+ if err != nil {
+ return err
+ }
+ table := array.NewTableFromRecords(records[0].Schema(), records)
+
+ props := parquet.NewWriterProperties(parquet.WithDictionaryDefault(false))
+ arrProps := pqarrow.DefaultWriterProps()
+ return pqarrow.WriteTable(table, writer, 1000, props, arrProps)
+}
+
+func (s *OfflineStoreSink) Flush(featureServiceName string) error {
+ if s.datasetDir == "" {
+ return nil
+ }
+
+ datasetDir := s.datasetDir
+ s.datasetDir = ""
+
+ go func() {
+ errMsg := s.writeCallback(featureServiceName, datasetDir)
+ if errMsg != "" {
+ log.Println(errMsg)
+ }
+ os.RemoveAll(datasetDir)
+ }()
+
+ return nil
+}
+
+
+
package logging
+
+import (
+ "sync"
+ "time"
+
+ "github.com/pkg/errors"
+
+ "github.com/feast-dev/feast/go/internal/feast/model"
+)
+
+type FeatureStore interface {
+ GetFcosMap() (map[string]*model.Entity, map[string]*model.FeatureView, map[string]*model.OnDemandFeatureView, error)
+ GetFeatureService(name string) (*model.FeatureService, error)
+}
+
+type LoggingOptions struct {
+ // How many log items can be buffered in channel
+ ChannelCapacity int
+
+ // Waiting time when inserting new log into the channel
+ EmitTimeout time.Duration
+
+ // Interval on which logs buffered in memory will be written to sink
+ WriteInterval time.Duration
+
+ // Interval on which sink will be flushed
+ // (see LogSink interface for better explanation on differences with Write)
+ FlushInterval time.Duration
+}
+
+type LoggingService struct {
+ // feature service name -> LoggerImpl
+ loggers map[string]*LoggerImpl
+
+ fs FeatureStore
+ sink LogSink
+ opts LoggingOptions
+
+ creationLock *sync.Mutex
+}
+
+var (
+ DefaultOptions = LoggingOptions{
+ ChannelCapacity: 100000,
+ FlushInterval: 10 * time.Minute,
+ WriteInterval: 10 * time.Second,
+ EmitTimeout: 10 * time.Millisecond,
+ }
+)
+
+func NewLoggingService(fs FeatureStore, sink LogSink, opts ...LoggingOptions) (*LoggingService, error) {
+ if len(opts) == 0 {
+ opts = append(opts, DefaultOptions)
+ }
+
+ return &LoggingService{
+ fs: fs,
+ loggers: make(map[string]*LoggerImpl),
+ sink: sink,
+ opts: opts[0],
+ creationLock: &sync.Mutex{},
+ }, nil
+}
+
+func (s *LoggingService) GetOrCreateLogger(featureService *model.FeatureService) (Logger, error) {
+ if logger, ok := s.loggers[featureService.Name]; ok {
+ return logger, nil
+ }
+
+ if featureService.LoggingConfig == nil {
+ return nil, errors.New("Only feature services with configured logging can be used")
+ }
+
+ s.creationLock.Lock()
+ defer s.creationLock.Unlock()
+
+ // could be created by another go-routine on this point
+ if logger, ok := s.loggers[featureService.Name]; ok {
+ return logger, nil
+ }
+
+ if s.sink == nil {
+ return &DummyLoggerImpl{}, nil
+ }
+
+ config := NewLoggerConfig(featureService.LoggingConfig.SampleRate, s.opts)
+ schema, err := GenerateSchemaFromFeatureService(s.fs, featureService.Name)
+ if err != nil {
+ return nil, err
+ }
+
+ logger, err := NewLogger(schema, featureService.Name, s.sink, config)
+ if err != nil {
+ return nil, err
+ }
+ s.loggers[featureService.Name] = logger
+
+ return logger, nil
+}
+
+func (s *LoggingService) Stop() {
+ for _, logger := range s.loggers {
+ logger.Stop()
+ logger.WaitUntilStopped()
+ }
+}
+
+
+
package server
+
+import (
+ "github.com/rs/zerolog"
+ "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+ "os"
+)
+
+func LogWithSpanContext(span tracer.Span) zerolog.Logger {
+ spanContext := span.Context()
+
+ var logger = zerolog.New(os.Stderr).With().
+ Int64("trace_id", int64(spanContext.TraceID())).
+ Int64("span_id", int64(spanContext.SpanID())).
+ Timestamp().
+ Logger()
+
+ return logger
+}
+
+
+
package main
+
+import (
+ "flag"
+ "fmt"
+ "net"
+ "os"
+ "os/signal"
+ "strings"
+ "syscall"
+
+ "github.com/feast-dev/feast/go/internal/feast"
+ "github.com/feast-dev/feast/go/internal/feast/registry"
+ "github.com/feast-dev/feast/go/internal/feast/server"
+ "github.com/feast-dev/feast/go/internal/feast/server/logging"
+ "github.com/feast-dev/feast/go/protos/feast/serving"
+ "github.com/rs/zerolog/log"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/health"
+ "google.golang.org/grpc/health/grpc_health_v1"
+
+ grpctrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/google.golang.org/grpc"
+ "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+)
+
+type ServerStarter interface {
+ StartHttpServer(fs *feast.FeatureStore, host string, port int, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) error
+ StartGrpcServer(fs *feast.FeatureStore, host string, port int, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) error
+}
+
+type RealServerStarter struct{}
+
+func (s *RealServerStarter) StartHttpServer(fs *feast.FeatureStore, host string, port int, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) error {
+ return StartHttpServer(fs, host, port, writeLoggedFeaturesCallback, loggingOpts)
+}
+
+func (s *RealServerStarter) StartGrpcServer(fs *feast.FeatureStore, host string, port int, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) error {
+ return StartGrpcServer(fs, host, port, writeLoggedFeaturesCallback, loggingOpts)
+}
+
+func main() {
+ // Default values
+ serverType := "http"
+ host := ""
+ port := 8080
+ server := RealServerStarter{}
+ // Current Directory
+ repoPath, err := os.Getwd()
+ if err != nil {
+ log.Error().Stack().Err(err).Msg("Failed to get current directory")
+ }
+
+ flag.StringVar(&serverType, "type", serverType, "Specify the server type (http or grpc)")
+ flag.StringVar(&repoPath, "chdir", repoPath, "Repository path where feature store yaml file is stored")
+
+ flag.StringVar(&host, "host", host, "Specify a host for the server")
+ flag.IntVar(&port, "port", port, "Specify a port for the server")
+ flag.Parse()
+
+ repoConfig, err := registry.NewRepoConfigFromFile(repoPath)
+ if err != nil {
+ log.Fatal().Stack().Err(err).Msg("Failed to convert to RepoConfig")
+ }
+
+ fs, err := feast.NewFeatureStore(repoConfig, nil)
+ if err != nil {
+ log.Fatal().Stack().Err(err).Msg("Failed to create NewFeatureStore")
+ }
+
+ loggingOptions, err := repoConfig.GetLoggingOptions()
+ if err != nil {
+ log.Fatal().Stack().Err(err).Msg("Failed to get LoggingOptions")
+ }
+
+ // TODO: writeLoggedFeaturesCallback is defaulted to nil. write_logged_features functionality needs to be
+ // implemented in Golang specific to OfflineStoreSink. Python Feature Server doesn't support this.
+ if serverType == "http" {
+ err = server.StartHttpServer(fs, host, port, nil, loggingOptions)
+ } else if serverType == "grpc" {
+ err = server.StartGrpcServer(fs, host, port, nil, loggingOptions)
+ } else {
+ fmt.Println("Unknown server type. Please specify 'http' or 'grpc'.")
+ }
+
+ if err != nil {
+ log.Fatal().Stack().Err(err).Msg("Failed to start server")
+ }
+
+}
+
+func constructLoggingService(fs *feast.FeatureStore, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) (*logging.LoggingService, error) {
+ var loggingService *logging.LoggingService = nil
+ if writeLoggedFeaturesCallback != nil {
+ sink, err := logging.NewOfflineStoreSink(writeLoggedFeaturesCallback)
+ if err != nil {
+ return nil, err
+ }
+
+ loggingService, err = logging.NewLoggingService(fs, sink, logging.LoggingOptions{
+ ChannelCapacity: loggingOpts.ChannelCapacity,
+ EmitTimeout: loggingOpts.EmitTimeout,
+ WriteInterval: loggingOpts.WriteInterval,
+ FlushInterval: loggingOpts.FlushInterval,
+ })
+ if err != nil {
+ return nil, err
+ }
+ }
+ return loggingService, nil
+}
+
+// StartGprcServerWithLogging starts gRPC server with enabled feature logging
+func StartGrpcServer(fs *feast.FeatureStore, host string, port int, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) error {
+ if strings.ToLower(os.Getenv("ENABLE_DATADOG_TRACING")) == "true" {
+ tracer.Start(tracer.WithRuntimeMetrics())
+ defer tracer.Stop()
+ }
+ loggingService, err := constructLoggingService(fs, writeLoggedFeaturesCallback, loggingOpts)
+ if err != nil {
+ return err
+ }
+ ser := server.NewGrpcServingServiceServer(fs, loggingService)
+ log.Info().Msgf("Starting a gRPC server on host %s port %d", host, port)
+ lis, err := net.Listen("tcp", fmt.Sprintf("%s:%d", host, port))
+ if err != nil {
+ return err
+ }
+
+ grpcServer := grpc.NewServer(grpc.UnaryInterceptor(grpctrace.UnaryServerInterceptor()))
+ serving.RegisterServingServiceServer(grpcServer, ser)
+ healthService := health.NewServer()
+ grpc_health_v1.RegisterHealthServer(grpcServer, healthService)
+
+ stop := make(chan os.Signal, 1)
+ signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
+
+ go func() {
+ // As soon as these signals are received from OS, try to gracefully stop the gRPC server
+ <-stop
+ log.Info().Msg("Stopping the gRPC server...")
+ grpcServer.GracefulStop()
+ if loggingService != nil {
+ loggingService.Stop()
+ }
+ log.Info().Msg("gRPC server terminated")
+ }()
+
+ return grpcServer.Serve(lis)
+}
+
+// StartHttpServerWithLogging starts HTTP server with enabled feature logging
+// Go does not allow direct assignment to package-level functions as a way to
+// mock them for tests
+func StartHttpServer(fs *feast.FeatureStore, host string, port int, writeLoggedFeaturesCallback logging.OfflineStoreWriteCallback, loggingOpts *logging.LoggingOptions) error {
+ loggingService, err := constructLoggingService(fs, writeLoggedFeaturesCallback, loggingOpts)
+ if err != nil {
+ return err
+ }
+ ser := server.NewHttpServer(fs, loggingService)
+ log.Info().Msgf("Starting a HTTP server on host %s, port %d", host, port)
+
+ stop := make(chan os.Signal, 1)
+ signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
+
+ go func() {
+ // As soon as these signals are received from OS, try to gracefully stop the gRPC server
+ <-stop
+ log.Info().Msg("Stopping the HTTP server...")
+ err := ser.Stop()
+ if err != nil {
+ log.Error().Err(err).Msg("Error when stopping the HTTP server")
+ }
+ if loggingService != nil {
+ loggingService.Stop()
+ }
+ log.Info().Msg("HTTP server terminated")
+ }()
+
+ return ser.Serve(host, port)
+}
+
+
+
package types
+
+import (
+ "fmt"
+
+ "github.com/apache/arrow/go/v8/arrow"
+ "github.com/apache/arrow/go/v8/arrow/array"
+ "github.com/apache/arrow/go/v8/arrow/memory"
+
+ "github.com/feast-dev/feast/go/protos/feast/types"
+)
+
+func ProtoTypeToArrowType(sample *types.Value) (arrow.DataType, error) {
+ if sample.Val == nil {
+ return nil, nil
+ }
+ switch sample.Val.(type) {
+ case *types.Value_BytesVal:
+ return arrow.BinaryTypes.Binary, nil
+ case *types.Value_StringVal:
+ return arrow.BinaryTypes.String, nil
+ case *types.Value_Int32Val:
+ return arrow.PrimitiveTypes.Int32, nil
+ case *types.Value_Int64Val:
+ return arrow.PrimitiveTypes.Int64, nil
+ case *types.Value_FloatVal:
+ return arrow.PrimitiveTypes.Float32, nil
+ case *types.Value_DoubleVal:
+ return arrow.PrimitiveTypes.Float64, nil
+ case *types.Value_BoolVal:
+ return arrow.FixedWidthTypes.Boolean, nil
+ case *types.Value_BoolListVal:
+ return arrow.ListOf(arrow.FixedWidthTypes.Boolean), nil
+ case *types.Value_StringListVal:
+ return arrow.ListOf(arrow.BinaryTypes.String), nil
+ case *types.Value_BytesListVal:
+ return arrow.ListOf(arrow.BinaryTypes.Binary), nil
+ case *types.Value_Int32ListVal:
+ return arrow.ListOf(arrow.PrimitiveTypes.Int32), nil
+ case *types.Value_Int64ListVal:
+ return arrow.ListOf(arrow.PrimitiveTypes.Int64), nil
+ case *types.Value_FloatListVal:
+ return arrow.ListOf(arrow.PrimitiveTypes.Float32), nil
+ case *types.Value_DoubleListVal:
+ return arrow.ListOf(arrow.PrimitiveTypes.Float64), nil
+ case *types.Value_UnixTimestampVal:
+ return arrow.FixedWidthTypes.Timestamp_s, nil
+ case *types.Value_UnixTimestampListVal:
+ return arrow.ListOf(arrow.FixedWidthTypes.Timestamp_s), nil
+ default:
+ return nil,
+ fmt.Errorf("unsupported proto type in proto to arrow conversion: %s", sample.Val)
+ }
+}
+
+func ValueTypeEnumToArrowType(t types.ValueType_Enum) (arrow.DataType, error) {
+ switch t {
+ case types.ValueType_BYTES:
+ return arrow.BinaryTypes.Binary, nil
+ case types.ValueType_STRING:
+ return arrow.BinaryTypes.String, nil
+ case types.ValueType_INT32:
+ return arrow.PrimitiveTypes.Int32, nil
+ case types.ValueType_INT64:
+ return arrow.PrimitiveTypes.Int64, nil
+ case types.ValueType_FLOAT:
+ return arrow.PrimitiveTypes.Float32, nil
+ case types.ValueType_DOUBLE:
+ return arrow.PrimitiveTypes.Float64, nil
+ case types.ValueType_BOOL:
+ return arrow.FixedWidthTypes.Boolean, nil
+ case types.ValueType_BOOL_LIST:
+ return arrow.ListOf(arrow.FixedWidthTypes.Boolean), nil
+ case types.ValueType_STRING_LIST:
+ return arrow.ListOf(arrow.BinaryTypes.String), nil
+ case types.ValueType_BYTES_LIST:
+ return arrow.ListOf(arrow.BinaryTypes.Binary), nil
+ case types.ValueType_INT32_LIST:
+ return arrow.ListOf(arrow.PrimitiveTypes.Int32), nil
+ case types.ValueType_INT64_LIST:
+ return arrow.ListOf(arrow.PrimitiveTypes.Int64), nil
+ case types.ValueType_FLOAT_LIST:
+ return arrow.ListOf(arrow.PrimitiveTypes.Float32), nil
+ case types.ValueType_DOUBLE_LIST:
+ return arrow.ListOf(arrow.PrimitiveTypes.Float64), nil
+ case types.ValueType_UNIX_TIMESTAMP:
+ return arrow.FixedWidthTypes.Timestamp_s, nil
+ case types.ValueType_UNIX_TIMESTAMP_LIST:
+ return arrow.ListOf(arrow.FixedWidthTypes.Timestamp_s), nil
+ default:
+ return nil,
+ fmt.Errorf("unsupported value type enum in enum to arrow type conversion: %s", t)
+ }
+}
+
+func CopyProtoValuesToArrowArray(builder array.Builder, values []*types.Value) error {
+ for _, value := range values {
+ if value == nil || value.Val == nil {
+ builder.AppendNull()
+ continue
+ }
+
+ switch fieldBuilder := builder.(type) {
+
+ case *array.BooleanBuilder:
+ fieldBuilder.Append(value.GetBoolVal())
+ case *array.BinaryBuilder:
+ fieldBuilder.Append(value.GetBytesVal())
+ case *array.StringBuilder:
+ fieldBuilder.Append(value.GetStringVal())
+ case *array.Int32Builder:
+ fieldBuilder.Append(value.GetInt32Val())
+ case *array.Int64Builder:
+ fieldBuilder.Append(value.GetInt64Val())
+ case *array.Float32Builder:
+ fieldBuilder.Append(value.GetFloatVal())
+ case *array.Float64Builder:
+ fieldBuilder.Append(value.GetDoubleVal())
+ case *array.TimestampBuilder:
+ fieldBuilder.Append(arrow.Timestamp(value.GetUnixTimestampVal()))
+ case *array.ListBuilder:
+ fieldBuilder.Append(true)
+
+ switch valueBuilder := fieldBuilder.ValueBuilder().(type) {
+
+ case *array.BooleanBuilder:
+ for _, v := range value.GetBoolListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.BinaryBuilder:
+ for _, v := range value.GetBytesListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.StringBuilder:
+ for _, v := range value.GetStringListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.Int32Builder:
+ for _, v := range value.GetInt32ListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.Int64Builder:
+ for _, v := range value.GetInt64ListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.Float32Builder:
+ for _, v := range value.GetFloatListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.Float64Builder:
+ for _, v := range value.GetDoubleListVal().GetVal() {
+ valueBuilder.Append(v)
+ }
+ case *array.TimestampBuilder:
+ for _, v := range value.GetUnixTimestampListVal().GetVal() {
+ valueBuilder.Append(arrow.Timestamp(v))
+ }
+ }
+ default:
+ return fmt.Errorf("unsupported array builder: %s", builder)
+ }
+ }
+ return nil
+}
+
+func ArrowValuesToProtoValues(arr arrow.Array) ([]*types.Value, error) {
+ values := make([]*types.Value, 0)
+
+ if listArr, ok := arr.(*array.List); ok {
+ listValues := listArr.ListValues()
+ offsets := listArr.Offsets()[1:]
+ pos := 0
+ for idx := 0; idx < listArr.Len(); idx++ {
+ switch listValues.DataType() {
+ case arrow.PrimitiveTypes.Int32:
+ vals := make([]int32, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.Int32).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_Int32ListVal{Int32ListVal: &types.Int32List{Val: vals}}})
+ case arrow.PrimitiveTypes.Int64:
+ vals := make([]int64, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.Int64).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_Int64ListVal{Int64ListVal: &types.Int64List{Val: vals}}})
+ case arrow.PrimitiveTypes.Float32:
+ vals := make([]float32, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.Float32).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_FloatListVal{FloatListVal: &types.FloatList{Val: vals}}})
+ case arrow.PrimitiveTypes.Float64:
+ vals := make([]float64, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.Float64).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_DoubleListVal{DoubleListVal: &types.DoubleList{Val: vals}}})
+ case arrow.BinaryTypes.Binary:
+ vals := make([][]byte, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.Binary).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_BytesListVal{BytesListVal: &types.BytesList{Val: vals}}})
+ case arrow.BinaryTypes.String:
+ vals := make([]string, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.String).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_StringListVal{StringListVal: &types.StringList{Val: vals}}})
+ case arrow.FixedWidthTypes.Boolean:
+ vals := make([]bool, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = listValues.(*array.Boolean).Value(j)
+ }
+ values = append(values,
+ &types.Value{Val: &types.Value_BoolListVal{BoolListVal: &types.BoolList{Val: vals}}})
+ case arrow.FixedWidthTypes.Timestamp_s:
+ vals := make([]int64, int(offsets[idx])-pos)
+ for j := pos; j < int(offsets[idx]); j++ {
+ vals[j-pos] = int64(listValues.(*array.Timestamp).Value(j))
+ }
+
+ values = append(values,
+ &types.Value{Val: &types.Value_UnixTimestampListVal{
+ UnixTimestampListVal: &types.Int64List{Val: vals}}})
+
+ }
+
+ // set the end of current element as start of the next
+ pos = int(offsets[idx])
+ }
+
+ return values, nil
+ }
+
+ switch arr.DataType() {
+ case arrow.PrimitiveTypes.Int32:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_Int32Val{Int32Val: arr.(*array.Int32).Value(idx)}})
+ }
+ }
+ case arrow.PrimitiveTypes.Int64:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_Int64Val{Int64Val: arr.(*array.Int64).Value(idx)}})
+ }
+ }
+ case arrow.PrimitiveTypes.Float32:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_FloatVal{FloatVal: arr.(*array.Float32).Value(idx)}})
+ }
+ }
+ case arrow.PrimitiveTypes.Float64:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_DoubleVal{DoubleVal: arr.(*array.Float64).Value(idx)}})
+ }
+ }
+ case arrow.FixedWidthTypes.Boolean:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_BoolVal{BoolVal: arr.(*array.Boolean).Value(idx)}})
+ }
+ }
+ case arrow.BinaryTypes.Binary:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_BytesVal{BytesVal: arr.(*array.Binary).Value(idx)}})
+ }
+ }
+ case arrow.BinaryTypes.String:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_StringVal{StringVal: arr.(*array.String).Value(idx)}})
+ }
+ }
+ case arrow.FixedWidthTypes.Timestamp_s:
+ for idx := 0; idx < arr.Len(); idx++ {
+ if arr.IsNull(idx) {
+ values = append(values, &types.Value{})
+ } else {
+ values = append(values, &types.Value{Val: &types.Value_UnixTimestampVal{UnixTimestampVal: int64(arr.(*array.Timestamp).Value(idx))}})
+ }
+ }
+ case arrow.Null:
+ for idx := 0; idx < arr.Len(); idx++ {
+ values = append(values, &types.Value{})
+ }
+ default:
+ return nil, fmt.Errorf("unsupported arrow to proto conversion for type %s", arr.DataType())
+ }
+
+ return values, nil
+}
+
+func ProtoValuesToArrowArray(protoValues []*types.Value, arrowAllocator memory.Allocator, numRows int) (arrow.Array, error) {
+ var fieldType arrow.DataType
+ var err error
+
+ for _, val := range protoValues {
+ if val != nil {
+ fieldType, err = ProtoTypeToArrowType(val)
+ if err != nil {
+ return nil, err
+ }
+ if fieldType != nil {
+ break
+ }
+ }
+ }
+
+ if fieldType != nil {
+ builder := array.NewBuilder(arrowAllocator, fieldType)
+ err = CopyProtoValuesToArrowArray(builder, protoValues)
+ if err != nil {
+ return nil, err
+ }
+
+ return builder.NewArray(), nil
+ } else {
+ return array.NewNull(numRows), nil
+ }
+}
+
+
+