// Enable will enable tracing for the given key, regardless of
// the environment variable
493563
func Enable(key string) {
	uppedKey := strings.ToUpper(key)
	if tracer, ok := tracers[uppedKey]; ok {
		tracer.enabled = true
	}
}
561780
func (d Driver) Enable() {
	d.mutex.Lock()
	defer d.mutex.Unlock()
	if !d.enabled {
		go d.flightLoop(d.stopc)
		d.enabled = true
	}
}
1072566
func init() {
	for _, arg := range os.Args {
		if flag := strings.TrimLeft(arg, "-"); flag == TracingEnabledFlag {
			Enabled = true
		}
	}
}
190155
func (m *OFPMechanism) Enable(c *mech.MechanismContext) {
	m.BaseMechanism.Enable(c)

	m.C.Mux.HandleFunc(of.T_ECHO_REQUEST, m.echoHandler)

	log.InfoLog("ofp/ENABLE_HOOK",
		"Mechanism ofp1.3 enabled")
}
587253
func (s *Server) Enable(extensions ...Extension) {
	s.extensions = append(s.extensions, extensions...)
}
1262304
func EmulationEnabled(c context.Context) bool {
	enabled, _ := c.Value(&emulationEnabledKey).(bool)
	return enabled
}
585532
func (s *Server) EnableAuth(name string, f SASLServerFactory) {
	s.auths[name] = f
}
1277953
func Enable(id ID, when When, what Action) error {
	if v, ok := chaos[id]; !ok {
		return ErrNoEnt
	} else {
		v.Enabled = true
		v.When = when
		v.What = what
	}
	return nil
}
555906
func (module *BBAnalogModule) Enable() error {
	// once-off initialisation of analog
	if !module.analogInitialised {
		path, e := findFirstMatchingFile("/sys/devices/bone_capemgr.*/slots")
		if e != nil {
			return e
		}

		// determine if cape-bone-iio is already in the file. If so, we've already initialised it.
		if !module.hasCapeBoneIIO(path) {
			// enable analog
			e = WriteStringToFile(path, "cape-bone-iio")
			if e != nil {
				return e
			}
		}

		// determine path where analog files are
		path, e = findFirstMatchingFile("/sys/devices/ocp.*/helper.*/AIN0")
		if e != nil {
			return e
		}
		if path == "" {
			return errors.New("Could not locate /sys/devices/ocp.*/helper.*/AIN0")
		}

		// remove AIN0 to get the path where these files are
		module.analogValueFilesPath = strings.TrimSuffix(path, "AIN0")

		module.analogInitialised = true

		// attempt to assign all pins to this module
		for pin, _ := range module.definedPins {
			// attempt to assign this pin for this module.
			e = AssignPin(pin, module)
			if e != nil {
				return e
			}
		}
	}
	return nil
}
1309999
func (this *Server) Enabled(n string) bool {
	return this.Get(n) == TRUE
}
368207
func Enable(addr string) <-chan error {
	errs := make(chan error, 1)

	go func() {
		// The Handler function provides a default handler to expose metrics
		// via an HTTP server. "/metrics" is the usual endpoint for that.
		http.Handle("/metrics", promhttp.HandlerFor(registry, promhttp.HandlerOpts{}))
		errs <- http.ListenAndServe(addr, nil)
	}()

	return errs
}
342007
func (s *stateTransitions) Enable() {
	s.Lock()

	if s.enabled {
		s.logger.Warn("state transition controller already enabled")
		s.Unlock()
		return
	}

	s.enabled = true
	s.Unlock()
	s.logger.Info("enabled state transition controller")
}
567146
func (h *healthcheckManager) enable() {
	h.lock.Lock()
	defer h.lock.Unlock()
	h.enabled = true
}
663
func EnableWithAIForwarding(agentEndpoint string) (err error) {
	err = Enable()
	if err != nil {
		return err
	}

	traceExporter, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithAddress(agentEndpoint))
	if err != nil {
		return err
	}
	trace.RegisterExporter(traceExporter)
	return
}
965463
func SetOpentracingEnabled(enabled bool) DBOption {
	return func(db *DB) error {
		db.OpentracingEnabled = enabled
		return nil
	}
}
1342694
func (ip *Interpreter) enable(args []string) {
	ip.simpleResponder(ip.Backend.EnableUser(args[0]))
}
95181
func (e *Engine) SetEnabled(enabled bool) {
	e.enableCompactionsOnOpen = enabled
	e.SetCompactionsEnabled(enabled)
}