Build has been canceled!

couchbase / moss / 184

pending completion

Build # 184

Build Type

push

travis-ci

Committed by

abhinavdangeti

Commit Message

MB-22732: Adding key-prefix option to hist subcommand for stats

+ Setting a key-prefix, will filter out results to fetch only
  keys with the set prefix.
+ Unit test

Change-Id: I1b8347169
Reviewed-on: http://review.couchbase.org/73711
Reviewed-by: Steve Yen <steve.yen@gmail.com>
Tested-by: abhinav dangeti <abhinav@couchbase.com>

Run Details

16 of 16 new or added lines in 1 file covered. (100.0%)

2805 of 3512 relevant lines covered (79.87%)

8272.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.21

/cmd/mossScope/cmd/hist.go

// Copyright © 2017 Couchbase, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
        "fmt"
        "strings"

        "github.com/couchbase/ghistogram"
        "github.com/couchbase/moss"
        "github.com/spf13/cobra"
)

// histCmd represents the hist command
var histCmd = &cobra.Command{
        Use:   "hist",
        Short: "Generates histograms for the store",
        Long: `This command generates histograms for various entities
available from the store.
        ./mossScope stats hist <path_to_store>`,

        PreRunE: func(cmd *cobra.Command, args []string) error {
                if len(args) < 1 {
                        return fmt.Errorf("At least one path is required!")
                }
                return nil
        },

        RunE: func(cmd *cobra.Command, args []string) error {
                return invokeHistStats(args)
        },
}

var keyPrefix string

func invokeHistStats(dirs []string) error {
        for _, dir := range dirs {
                store, err := moss.OpenStore(dir, ReadOnlyMode)
                if err != nil || store == nil {
                        return fmt.Errorf("Moss-OpenStore() API failed, err: %v", err)
                }

                snap, err := store.Snapshot()
                if err != nil || snap == nil {
                        fmt.Errorf("Store-Snapshot() API failed, err: %v", err)
                }

                iter, err := snap.StartIterator(nil, nil, moss.IteratorOptions{})
                if err != nil || iter == nil {
                        return fmt.Errorf("Snaphot-StartItr() API failed, err: %v", err)
                }

                keySizes := ghistogram.NewNamedHistogram("KeySizes(B) ", 10, 4, 4)
                valSizes := ghistogram.NewNamedHistogram("ValSizes(B) ", 10, 4, 4)

                for {
                        k, v, err := iter.Current()
                        if err != nil {
                                break
                        }

                        if len(keyPrefix) != 0 {
                                // A specific keyPrefix has been requested
                                if strings.HasPrefix(string(k), keyPrefix) {
                                        keySizes.Add(uint64(len(k)), 1)
                                        valSizes.Add(uint64(len(v)), 1)
                                }
                        } else {
                                keySizes.Add(uint64(len(k)), 1)
                                valSizes.Add(uint64(len(v)), 1)
                        }

                        if iter.Next() == moss.ErrIteratorDone {
                                break
                        }
                }

                fmt.Printf("\"%s\"\n", dir)
                fmt.Println((keySizes.EmitGraph(nil, nil)).String())
                fmt.Println((valSizes.EmitGraph(nil, nil)).String())

                iter.Close()
                snap.Close()
                store.Close()
        }

        return nil
}

func init() {
        statsCmd.AddCommand(histCmd)

        // Local flag that is intended to work as a flag over stats hist
        histCmd.Flags().StringVar(&keyPrefix, "key-prefix", "",
                "Emits histograms of keys that begin with the specified prefix")
}

1	// Copyright © 2017 Couchbase, Inc.
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package cmd
16
17	import (
18	"fmt"
19	"strings"
20
21	"github.com/couchbase/ghistogram"
22	"github.com/couchbase/moss"
23	"github.com/spf13/cobra"
24	)
25
26	// histCmd represents the hist command
27	var histCmd = &cobra.Command{
28	Use: "hist",
29	Short: "Generates histograms for the store",
30	Long: `This command generates histograms for various entities
31	available from the store.
32	./mossScope stats hist <path_to_store>`,
33
34	PreRunE: func(cmd *cobra.Command, args []string) error {	×
35	if len(args) < 1 {	×
36	return fmt.Errorf("At least one path is required!")	×
37	}	×
38	return nil	×
39	},
40
41	RunE: func(cmd *cobra.Command, args []string) error {	×
42	return invokeHistStats(args)	×
43	},	×
44	}
45
46	var keyPrefix string
47
48	func invokeHistStats(dirs []string) error {	2✔
49	for _, dir := range dirs {	4✔
50	store, err := moss.OpenStore(dir, ReadOnlyMode)	2✔
51	if err != nil \|\| store == nil {	2✔
52	return fmt.Errorf("Moss-OpenStore() API failed, err: %v", err)	×
53	}	×
54
55	snap, err := store.Snapshot()	2✔
56	if err != nil \|\| snap == nil {	2✔
57	fmt.Errorf("Store-Snapshot() API failed, err: %v", err)	×
58	}	×
59
60	iter, err := snap.StartIterator(nil, nil, moss.IteratorOptions{})	2✔
61	if err != nil \|\| iter == nil {	2✔
62	return fmt.Errorf("Snaphot-StartItr() API failed, err: %v", err)	×
63	}	×
64
65	keySizes := ghistogram.NewNamedHistogram("KeySizes(B) ", 10, 4, 4)	2✔
66	valSizes := ghistogram.NewNamedHistogram("ValSizes(B) ", 10, 4, 4)	2✔
67		2✔
68	for {	12✔
69	k, v, err := iter.Current()	10✔
70	if err != nil {	10✔
71	break	×
72	}
73
74	if len(keyPrefix) != 0 {	15✔
75	// A specific keyPrefix has been requested	5✔
76	if strings.HasPrefix(string(k), keyPrefix) {	6✔
77	keySizes.Add(uint64(len(k)), 1)	1✔
78	valSizes.Add(uint64(len(v)), 1)	1✔
79	}	1✔
80	} else {	5✔
81	keySizes.Add(uint64(len(k)), 1)	5✔
82	valSizes.Add(uint64(len(v)), 1)	5✔
83	}	5✔
84
85	if iter.Next() == moss.ErrIteratorDone {	12✔
86	break	2✔
87	}
88	}
89
90	fmt.Printf("\"%s\"\n", dir)	2✔
91	fmt.Println((keySizes.EmitGraph(nil, nil)).String())	2✔
92	fmt.Println((valSizes.EmitGraph(nil, nil)).String())	2✔
93		2✔
94	iter.Close()	2✔
95	snap.Close()	2✔
96	store.Close()	2✔
97	}
98
99	return nil	2✔
100	}
101
102	func init() {	2✔
103	statsCmd.AddCommand(histCmd)	2✔
104		2✔
105	// Local flag that is intended to work as a flag over stats hist	2✔
106	histCmd.Flags().StringVar(&keyPrefix, "key-prefix", "",	2✔
107	"Emits histograms of keys that begin with the specified prefix")	2✔
108	}	2✔

couchbase / moss / 184

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous