diff --git a/field.go b/field.go
index 0b2cf6cf5..6ef362728 100644
--- a/field.go
+++ b/field.go
@@ -379,27 +379,33 @@ func (f *Field) Options() FieldOptions {
 func (f *Field) Open() error {
 	if err := func() error {
 		// Ensure the field's path exists.
+		f.logger.Debugf("ensure field path exists: %s", f.path)
 		if err := os.MkdirAll(f.path, 0777); err != nil {
 			return errors.Wrap(err, "creating field dir")
 		}
 
+		f.logger.Debugf("load meta file for index/field: %s/%s", f.index, f.name)
 		if err := f.loadMeta(); err != nil {
 			return errors.Wrap(err, "loading meta")
 		}
 
+		f.logger.Debugf("load available shards for index/field: %s/%s", f.index, f.name)
 		if err := f.loadAvailableShards(); err != nil {
 			return errors.Wrap(err, "loading available shards")
 		}
 
 		// Apply the field options loaded from meta.
+		f.logger.Debugf("apply options for index/field: %s/%s", f.index, f.name)
 		if err := f.applyOptions(f.options); err != nil {
 			return errors.Wrap(err, "applying options")
 		}
 
+		f.logger.Debugf("open views for index/field: %s/%s", f.index, f.name)
 		if err := f.openViews(); err != nil {
 			return errors.Wrap(err, "opening views")
 		}
 
+		f.logger.Debugf("open row attribute store for index/field: %s/%s", f.index, f.name)
 		if err := f.rowAttrStore.Open(); err != nil {
 			return errors.Wrap(err, "opening attrstore")
 		}
@@ -410,6 +416,7 @@ func (f *Field) Open() error {
 		return err
 	}
 
+	f.logger.Debugf("successfully opened field index/field: %s/%s", f.index, f.name)
 	return nil
 }
 
@@ -434,11 +441,13 @@ func (f *Field) openViews() error {
 		}
 
 		name := filepath.Base(fi.Name())
+		f.logger.Debugf("open index/field/view: %s/%s/%s", f.index, f.name, fi.Name())
 		view := f.newView(f.viewPath(name), name)
 		if err := view.open(); err != nil {
 			return fmt.Errorf("opening view: view=%s, err=%s", view.name, err)
 		}
 		view.rowAttrStore = f.rowAttrStore
+		f.logger.Debugf("add index/field/view to field.viewMap: %s/%s/%s", f.index, f.name, view.name)
 		f.viewMap[view.name] = view
 	}
 
diff --git a/fragment.go b/fragment.go
index c08571e78..7c24a5d66 100644
--- a/fragment.go
+++ b/fragment.go
@@ -163,11 +163,13 @@ func (f *fragment) Open() error {
 
 	if err := func() error {
 		// Initialize storage in a function so we can close if anything goes wrong.
+		f.Logger.Debugf("open storage for index/field/view/fragment: %s/%s/%s/%d", f.index, f.field, f.view, f.shard)
 		if err := f.openStorage(); err != nil {
 			return errors.Wrap(err, "opening storage")
 		}
 
 		// Fill cache with rows persisted to disk.
+		f.Logger.Debugf("open cache for index/field/view/fragment: %s/%s/%s/%d", f.index, f.field, f.view, f.shard)
 		if err := f.openCache(); err != nil {
 			return errors.Wrap(err, "opening cache")
 		}
@@ -185,6 +187,7 @@ func (f *fragment) Open() error {
 		return err
 	}
 
+	f.Logger.Debugf("successfully opened index/field/view/fragment: %s/%s/%s/%d", f.index, f.field, f.view, f.shard)
 	return nil
 }
 
diff --git a/index.go b/index.go
index 8b67f003c..dbb9c052a 100644
--- a/index.go
+++ b/index.go
@@ -107,15 +107,18 @@ func (i *Index) options() IndexOptions {
 // Open opens and initializes the index.
 func (i *Index) Open() error {
 	// Ensure the path exists.
+	i.logger.Debugf("ensure index path exists: %s", i.path)
 	if err := os.MkdirAll(i.path, 0777); err != nil {
 		return errors.Wrap(err, "creating directory")
 	}
 
 	// Read meta file.
+	i.logger.Debugf("load meta file for index: %s", i.name)
 	if err := i.loadMeta(); err != nil {
 		return errors.Wrap(err, "loading meta file")
 	}
 
+	i.logger.Debugf("open fields for index: %s", i.name)
 	if err := i.openFields(); err != nil {
 		return errors.Wrap(err, "opening fields")
 	}
@@ -151,6 +154,7 @@ func (i *Index) openFields() error {
 			continue
 		}
 
+		i.logger.Debugf("open field: %s", fi.Name())
 		fld, err := i.newField(i.fieldPath(filepath.Base(fi.Name())), filepath.Base(fi.Name()))
 		if err != nil {
 			return errors.Wrapf(ErrName, "'%s'", fi.Name())
@@ -158,6 +162,7 @@ func (i *Index) openFields() error {
 		if err := fld.Open(); err != nil {
 			return fmt.Errorf("open field: name=%s, err=%s", fld.Name(), err)
 		}
+		i.logger.Debugf("add field to index.fields: %s", fi.Name())
 		i.fields[fld.Name()] = fld
 	}
 	return nil
diff --git a/view.go b/view.go
index f53cba183..e8894db7d 100644
--- a/view.go
+++ b/view.go
@@ -88,12 +88,14 @@ func (v *view) open() error {
 
 	if err := func() error {
 		// Ensure the view's path exists.
+		v.logger.Debugf("ensure view path exists: %s", v.path)
 		if err := os.MkdirAll(v.path, 0777); err != nil {
 			return errors.Wrap(err, "creating view directory")
 		} else if err := os.MkdirAll(filepath.Join(v.path, "fragments"), 0777); err != nil {
 			return errors.Wrap(err, "creating fragments directory")
 		}
 
+		v.logger.Debugf("open fragments for index/field/view: %s/%s/%s", v.index, v.field, v.name)
 		if err := v.openFragments(); err != nil {
 			return errors.Wrap(err, "opening fragments")
 		}
@@ -104,6 +106,7 @@ func (v *view) open() error {
 		return err
 	}
 
+	v.logger.Debugf("successfully opened index/field/view: %s/%s/%s", v.index, v.field, v.name)
 	return nil
 }
 
@@ -130,14 +133,17 @@ func (v *view) openFragments() error {
 		// Parse filename into integer.
 		shard, err := strconv.ParseUint(filepath.Base(fi.Name()), 10, 64)
 		if err != nil {
+			v.logger.Debugf("WARNING: couldn't use non-integer file as shard in index/field/view %s/%s/%s: %s", v.index, v.field, v.name, fi.Name())
 			continue
 		}
 
+		v.logger.Debugf("open index/field/view/fragment: %s/%s/%s/%d", v.index, v.field, v.name, shard)
 		frag := v.newFragment(v.fragmentPath(shard), shard)
 		if err := frag.Open(); err != nil {
 			return fmt.Errorf("open fragment: shard=%d, err=%s", frag.shard, err)
 		}
 		frag.RowAttrStore = v.rowAttrStore
+		v.logger.Debugf("add index/field/view/fragment to view.fragments: %s/%s/%s/%d", v.index, v.field, v.name, shard)
 		v.fragments[frag.shard] = frag
 	}