Add lakefs instrumentation

README.md

@@ -38,7 +38,7 @@ docker run --pull always \
 		   --name lakefs \
 		   -p 8000:8000 \
 		   treeverse/lakefs:latest \
-		   run --local-settings
+		   run --quickstart
 ```
 
 Once you've got lakeFS running, open [http://127.0.0.1:8000/](http://127.0.0.1:8000/) in your web browser.

cmd/lakefs/cmd/root.go

@@ -11,7 +11,9 @@ import (
 	"github.com/mitchellh/go-homedir"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"github.com/treeverse/lakefs/pkg/block"
 	"github.com/treeverse/lakefs/pkg/config"
+	"github.com/treeverse/lakefs/pkg/kv/local"
 	"github.com/treeverse/lakefs/pkg/logging"
 	"github.com/treeverse/lakefs/pkg/version"
 )
@@ -41,26 +43,50 @@ func init() {
 	rootCmd.PersistentFlags().StringVarP(&cfgFile, "config", "c", "", "config file (default is $HOME/.lakefs.yaml)")
 	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 	rootCmd.PersistentFlags().Bool(config.UseLocalConfiguration, false, "Use lakeFS local default configuration")
+	rootCmd.PersistentFlags().Bool(config.QuickStartConfiguration, false, "Use lakeFS quickstart configuration")
 }
 
-func useLocal() bool {
-	res, err := rootCmd.PersistentFlags().GetBool(config.UseLocalConfiguration)
+func validateQuickstartEnv(cfg *config.Config) {
+	if cfg.Database.Type != local.DriverName || cfg.Blockstore.Type != block.BlockstoreTypeLocal {
+		fmt.Printf("quickstart mode can only run with local settings\n")
+		os.Exit(1)
+	}
+	accessKey := "AKIAIOSFOLQUICKSTART"
+	secretKey := "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+	cfg.Installation.UserName = "quickstart"
+	cfg.Installation.AccessKeyID = config.SecureString(accessKey)
+	cfg.Installation.SecretAccessKey = config.SecureString(secretKey)
+	fmt.Printf("Access Key ID    : %s \n", accessKey)
+	fmt.Printf("Secret Access Key: %s \n", secretKey)
+}
+
+func useConfig(cfg string) bool {
+	res, err := rootCmd.PersistentFlags().GetBool(cfg)
 	if err != nil {
-		fmt.Printf("%s: %s\n", config.UseLocalConfiguration, err)
+		fmt.Printf("%s: %s\n", cfg, err)
 		os.Exit(1)
 	}
 	if res {
-		printLocalWarning(os.Stderr, "local parameters configuration")
+		printLocalWarning(os.Stderr, fmt.Sprintf("%s parameters configuration", cfg))
 	}
 	return res
 }
 
 func newConfig() (*config.Config, error) {
-	if useLocal() {
-		return config.NewLocalConfig()
-	}
+	quickStart := useConfig(config.QuickStartConfiguration)
 
-	return config.NewConfig()
+	if useConfig(config.UseLocalConfiguration) || quickStart {
+		cfg, err := config.NewLocalConfig()
+		if err != nil {
+			return nil, err
+		}
+		if quickStart {
+			validateQuickstartEnv(cfg)
+		}
+		return cfg, err
+	} else {
+		return config.NewConfig()
+	}
 }
 
 func loadConfig() *config.Config {

cmd/lakefs/cmd/run.go

@@ -495,7 +495,7 @@ func printWelcome(w io.Writer) {
 const localWarningBanner = `
 WARNING!
 
-Using %s.  This is suitable only for testing! It is NOT SUPPORTED for production.
+Using %s. This is suitable only for testing! It is NOT SUPPORTED for production.
 `
 
 func printLocalWarning(w io.Writer, msg string) {

docs/quickstart/launch.md

@@ -21,30 +21,24 @@ Launch the lakeFS container:
 docker run --name lakefs --pull always \
              --rm --publish 8000:8000 \
              treeverse/lakefs:latest \
-             run --local-settings
+             run --quickstart
 ```
 
-After a few moments you should see the lakeFS container ready to use: 
+Quickstart mode includes initial setup and lakeFS is ready for use!
+The lakeFS quickstart credentials are:
 
 ```
-[…]
-│
-│ If you're running lakeFS locally for the first time,
-│     complete the setup process at http://127.0.0.1:8000/setup
-│
-[…]
-
+│     Access Key ID    : "AKIAIOSFOLQUICKSTART"
+│     Secret Access Key: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
 ```
 
 You're now ready to dive into lakeFS! 
 
-1. Open lakeFS's web interface at [http://127.0.0.1:8000/](http://127.0.0.1:8000/), enter your email address, and then click **Setup**.
-
-2. Make a note of the Access Key ID and Secret Access Key and click on **Go To Login**. 
+1. Open lakeFS's web interface at [http://127.0.0.1:8000/](http://127.0.0.1:8000/), enter your email address, and then click **Go to Login**.
 
-3. Login with the credentials that you've just created. 
+2. Login with the quickstart credentials. 
 
-4. You'll notice that there aren't any repositories created yet. Click the **Create Sample Repository** button. 
+3. You'll notice that there aren't any repositories created yet. Click the **Create Sample Repository** button. 
 
     <img width="75%" src="/assets/img/quickstart/empty-repo-list.png" alt="Empty lakeFS Repository list" class="quickstart"/>
 

pkg/auth/metadata.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"encoding/base64"
 	"errors"
+	"os"
 	"runtime"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
@@ -20,6 +22,10 @@ const (
 	EmailKeyName           = "encoded_user_email"
 	FeatureUpdatesKeyName  = "feature_updates"
 	SecurityUpdatesKeyName = "security_updates"
+
+	InstrumentationSamplesRepo = "SamplesRepo"
+	InstrumentationQuickstart  = "Quickstart"
+	InstrumentationRun         = "Run"
 )
 
 type SetupStateName string
@@ -206,13 +212,45 @@ func (m *KVMetadataManager) IsInitialized(ctx context.Context) (bool, error) {
 	return !setupTimestamp.IsZero(), nil
 }
 
+// DockeEnvExists For testing purposes
+var DockeEnvExists = "/.dockerenv"
+
+func inK8sMetadata() string {
+	_, k8s := os.LookupEnv("KUBERNETES_SERVICE_HOST")
+	return strconv.FormatBool(k8s)
+}
+
+func inDockerMetadata() string {
+	var err error
+	if DockeEnvExists != "" {
+		_, err = os.Stat(DockeEnvExists)
+	}
+	return strconv.FormatBool(err == nil)
+}
+
+func getInstrumentationMetadata() string {
+	lakefsAccessKeyID := os.Getenv("LAKEFS_ACCESS_KEY_ID")
+	switch {
+	case strings.HasSuffix(lakefsAccessKeyID, "LKFSSAMPLES"):
+		return InstrumentationSamplesRepo
+	case strings.HasSuffix(lakefsAccessKeyID, "QUICKSTART"):
+		return InstrumentationQuickstart
+	default:
+		return InstrumentationRun
+	}
+}
+
 func (m *KVMetadataManager) GetMetadata(ctx context.Context) (map[string]string, error) {
 	metadata := make(map[string]string)
 	metadata["lakefs_version"] = m.version
 	metadata["lakefs_kv_type"] = m.kvType
 	metadata["golang_version"] = runtime.Version()
 	metadata["architecture"] = runtime.GOARCH
 	metadata["os"] = runtime.GOOS
+	metadata["is_k8s"] = inK8sMetadata()
+	metadata["is_docker"] = inDockerMetadata()
+	metadata["instrumentation"] = getInstrumentationMetadata()
+
 	err := m.writeMetadata(ctx, metadata)
 	if err != nil {
 		return nil, err

pkg/auth/metadata_test.go

@@ -0,0 +1,53 @@
+package auth_test
+
+import (
+	"context"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/treeverse/lakefs/pkg/auth"
+	"github.com/treeverse/lakefs/pkg/auth/model"
+	"github.com/treeverse/lakefs/pkg/kv/kvtest"
+)
+
+func validateInstrumentation(t *testing.T, ctx context.Context, mgr *auth.KVMetadataManager, inst string, k8s, docker bool) {
+	md, err := mgr.GetMetadata(ctx)
+	require.NoError(t, err)
+	require.Equal(t, inst, md["instrumentation"])
+	require.Equal(t, strconv.FormatBool(k8s), md["is_k8s"])
+	require.Equal(t, strconv.FormatBool(docker), md["is_docker"])
+}
+
+func TestInstrumentation(t *testing.T) {
+	ctx := context.Background()
+	kvStore := kvtest.GetStore(ctx, t)
+
+	_ = kvStore.Set(ctx, []byte(model.PartitionKey), []byte(model.MetadataKeyPath(auth.SetupTimestampKeyName)), []byte(time.Now().Format(time.RFC3339)))
+	mgr := auth.NewKVMetadataManager("test", "12345", "mem", kvStore)
+
+	// No env vars - defaults to run
+	validateInstrumentation(t, ctx, mgr, auth.InstrumentationRun, false, false)
+
+	// Add quickstart env var with wrong value
+	require.NoError(t, os.Setenv("QUICKSTART", "fff"))
+	validateInstrumentation(t, ctx, mgr, auth.InstrumentationRun, false, false)
+
+	// Add docker env file
+	auth.DockeEnvExists = ""
+	validateInstrumentation(t, ctx, mgr, auth.InstrumentationRun, false, true)
+
+	// Add sample repo env var
+	require.NoError(t, os.Setenv("LAKEFS_ACCESS_KEY_ID", "LKFSSAMPLES"))
+	validateInstrumentation(t, ctx, mgr, auth.InstrumentationSamplesRepo, false, true)
+
+	// Add quickstart env var with right value
+	require.NoError(t, os.Setenv("LAKEFS_ACCESS_KEY_ID", "QUICKSTART"))
+	validateInstrumentation(t, ctx, mgr, auth.InstrumentationQuickstart, false, true)
+
+	// Add K8s env var
+	require.NoError(t, os.Setenv("KUBERNETES_SERVICE_HOST", ""))
+	validateInstrumentation(t, ctx, mgr, auth.InstrumentationQuickstart, true, true)
+}

pkg/config/config.go

@@ -35,7 +35,10 @@ var (
 
 // UseLocalConfiguration set to true will add defaults that enable a lakeFS run
 // without any other configuration like DB or blockstore.
-const UseLocalConfiguration = "local-settings"
+const (
+	UseLocalConfiguration   = "local-settings"
+	QuickStartConfiguration = "quickstart"
+)
 
 type OIDC struct {
 	// configure how users are handled on the lakeFS side:

pkg/samplerepo/assets/sample/README.md.tmpl

@@ -633,7 +633,7 @@ Alternatively you might want to have a look at [lakeFS Cloud](https://lakefs.clo
 
 ## lakeFS Samples
 
-The [lakeFS Samples](https://github.com/treeverse/lakeFS-samples) GitHub repository includes some excellent examples including.
+The [lakeFS Samples](https://github.com/treeverse/lakeFS-samples) GitHub repository includes some excellent examples including:
 
 * How to implement multi-table transaction on multiple Delta Tables
 * Notebooks to show integration of lakeFS with Spark, Python, Delta Lake, Airflow and Hooks.