func (h *GlogHandler) Vmodule(ruleset string) error {
	var filter []pattern
	for _, rule := range strings.Split(ruleset, ",") {
		if len(rule) == 0 {
			continue
		}
		parts := strings.Split(rule, "=")
		if len(parts) != 2 {
			return errVmoduleSyntax
		}
		parts[0] = strings.TrimSpace(parts[0])
		parts[1] = strings.TrimSpace(parts[1])
		if len(parts[0]) == 0 || len(parts[1]) == 0 {
			return errVmoduleSyntax
		}
		level, err := strconv.Atoi(parts[1])
		if err != nil {
			return errVmoduleSyntax
		}
		if level <= 0 {
			continue  
		}
		matcher := ".*"
		for _, comp := range strings.Split(parts[0], "/") {
			if comp == "*" {
				matcher += "(/.*)?"
			} else if comp != "" {
				matcher += "/" + regexp.QuoteMeta(comp)
			}
		}
		if !strings.HasSuffix(parts[0], ".go") {
			matcher += "/[^/]+\\.go"
		}
		matcher = matcher + "$"
		re, _ := regexp.Compile(matcher)
		filter = append(filter, pattern{re, Lvl(level)})
	}
	h.lock.Lock()
	defer h.lock.Unlock()
	h.patterns = filter
	h.siteCache = make(map[uintptr]Lvl)
	atomic.StoreUint32(&h.override, uint32(len(filter)))
	return nil
}
Vmodule sets the glog verbosity pattern.

The syntax of the argument is a comma-separated list of pattern=N, where the
pattern is a literal file name or "glob" pattern matching and N is a V level.

For instance:

pattern="gopher.go=3"
sets the V level to 3 in all Go files named "gopher.go"

pattern="foo=3"
sets V to 3 in all files of any packages whose import path ends in "foo"

pattern="foo/*=3"
sets V to 3 in all files of any packages whose import path contains "foo"
package log
import (
	"errors"
	"fmt"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
)
var errVmoduleSyntax = errors.New("expect comma-separated list of filename=N")
var errTraceSyntax = errors.New("expect file.go:234")
type GlogHandler struct {
	origin Handler  
	level     uint32  
	override  uint32  
	backtrace uint32  
	patterns  []pattern        
	siteCache map[uintptr]Lvl  
	location  string           
	lock      sync.RWMutex     
}
func NewGlogHandler(h Handler) *GlogHandler {
	return &GlogHandler{
		origin: h,
	}
}
func (h *GlogHandler) SetHandler(nh Handler) {
	h.origin = nh
}
type pattern struct {
	pattern *regexp.Regexp
	level   Lvl
}
func (h *GlogHandler) Verbosity(level Lvl) {
	atomic.StoreUint32(&h.level, uint32(level))
}