updates if debugging or not

@param debug if value is null server setting is used
@throws SecurityException
347317
public void updateDebug(Boolean debug, Boolean database, Boolean exception, Boolean tracing, Boolean dump, Boolean timer, Boolean implicitAccess, Boolean queryUsage)
	    throws SecurityException {
	checkWriteAccess();
	boolean hasAccess = ConfigWebUtil.hasAccess(config, SecurityManager.TYPE_DEBUGGING);
	if (!hasAccess) throw new SecurityException("no access to change debugging settings");
	Element debugging = _getRootElement("debugging");

	if (debug != null) debugging.setAttribute("debug", Caster.toString(debug.booleanValue()));
	else debugging.removeAttribute("debug");

	if (database != null) debugging.setAttribute("database", Caster.toString(database.booleanValue()));
	else debugging.removeAttribute("database");

	if (exception != null) debugging.setAttribute("exception", Caster.toString(exception.booleanValue()));
	else debugging.removeAttribute("exception");

	if (tracing != null) debugging.setAttribute("tracing", Caster.toString(tracing.booleanValue()));
	else debugging.removeAttribute("tracing");

	if (dump != null) debugging.setAttribute("dump", Caster.toString(dump.booleanValue()));
	else debugging.removeAttribute("dump");

	if (timer != null) debugging.setAttribute("timer", Caster.toString(timer.booleanValue()));
	else debugging.removeAttribute("timer");

	if (implicitAccess != null) debugging.setAttribute("implicit-access", Caster.toString(implicitAccess.booleanValue()));
	else debugging.removeAttribute("implicit-access");

	if (queryUsage != null) debugging.setAttribute("query-usage", Caster.toString(queryUsage.booleanValue()));
	else debugging.removeAttribute("query-usage");

    }
1172690
public static synchronized void update(Map<String, Object> newConfig) {
        if (newConfig == null)
            throw new NullPointerException("Updated config must not be null");

        boolean traceWasDisabled = !TraceComponent.isAnyTracingEnabled();

        // Update the logging configuration
        LogProviderConfig config = loggingConfig.get().get();
        if (config != null) {
            config.update(newConfig);

            Object o = newConfig.get("suppressSensitiveTrace");

            if (o != null) {
                if (o instanceof String) {
                    suppressSensitiveTrace = Boolean.parseBoolean((String) o);
                } else if (o instanceof Boolean) {
                    suppressSensitiveTrace = (Boolean) o;
                }
                if (suppressSensitiveTrace == true && safeLevelsIndex == null) {
                    setupSafeLevelsIndex();
                }
            }

            TraceSpecification newTs = setTraceSpec(config.getTraceString());

            // For updates only, warn if there are strings that we don't know
            if (defaultUpdated && newTs != null)
                newTs.warnUnmatchedSpecs();

            // we've updated the defaults from server.xml (we can set this a million times.. 
            // first pass through is the key.. 
            defaultUpdated = true;

            // Propagate updates to the delegate
            getDelegate().update(config);
        }

        // issue warning if trace has been enabled and there's no instrumentation agent
        if (!instrumentationAvailable && traceWasDisabled && TraceComponent.isAnyTracingEnabled()) {
            Tr.warning(TraceSpecification.getTc(), "INSTRUMENTATION_SERVICE_UNAVAILABLE");
        }
    }
484671
private void setupDebugger(Debugger debugger) {
        if (debugger == null) {
            return;
        }

        this.debugger = debugger;
        JSObject globalObject = getGlobalContext().getObject();
        String debuggerName = getRuntime().getConfig().getExposeDebugAs();
        Object currentDebugger = globalObject.get(this, debuggerName);
        if (!(currentDebugger instanceof DebuggerAPI)) {
            DebuggerAPI api = new DebuggerAPI(getGlobalContext(), debugger);
            globalObject.put(this, debuggerName, api, false);
        }
    }
960591
public function setCurlDebugging($debug = true) {
        $this->blocktrailClient->setCurlDebugging($debug);
        $this->dataClient->setCurlDebugging($debug);
    }
1189014
@Override
    public synchronized void updateServerLease(String recoveryIdentity, String recoveryGroup, boolean isServerStartup) throws Exception
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "updateServerLease", new java.lang.Object[] { recoveryIdentity, recoveryGroup, isServerStartup, this });

        Connection conn = null;
        Exception currentEx = null;
        Statement lockingStmt = null;
        PreparedStatement updateStmt = null;
        ResultSet lockingRS = null;

        if (tc.isDebugEnabled())
            Tr.debug(tc, "Work with recoveryIdentity - ", recoveryIdentity);

        // Reset a null recoveryGroup to an empty string
        if (recoveryGroup == null)
            recoveryGroup = "";

        try
        {
            // Have we acquired the reference to the DataSource yet?
            if (_theDS == null)
            {
                _theDS = getDataSourceFromProperties();
                // We've looked up the DS, so now we can get a JDBC connection
                if (_theDS != null)
                {
                    conn = getConnection(_theDS);
                }
            }
            else
            {
                // Try and get a new connection
                conn = _theDS.getConnection();
            }

            // If we were unable to get a connection, throw an exception
            if (conn == null)
            {
                if (tc.isEntryEnabled())
                    Tr.exit(tc, "updateServerLease", "Null connection InternalLogException");
                throw new InternalLogException("Failed to get JDBC Connection", null);
            }

            if (tc.isDebugEnabled())
                Tr.debug(tc, "Set autocommit FALSE on the connection");
            conn.setAutoCommit(false);

            // We can go ahead and write to the Database
            lockingStmt = conn.createStatement();
            //lockingStmt.setCursorName("UPDATESTATEMENT");
            boolean newTable = true;

            try
            {
                String queryString = "SELECT LEASE_TIME, LEASE_OWNER" +
                                     " FROM " + _leaseTableName +
                                     " WHERE SERVER_IDENTITY='" + recoveryIdentity + "' FOR UPDATE OF LEASE_TIME";
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "Attempt to select the row for UPDATE using - " + queryString);
                lockingRS = lockingStmt.executeQuery(queryString);

                newTable = false;
            } catch (Exception e)
            {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "Query failed with exception: " + e);
                currentEx = e;
            } // eof Exception e block

            if (currentEx != null)
            {
                if (isServerStartup)
                {
                    // Perhaps we couldn't find the table ... so attempt to create it
                    synchronized (_CreateTableLock) // Guard against trying to create a table from multiple threads
                    {
                        try
                        {
                            Tr.audit(tc, "WTRN0108I: Create Shared Lease Table");
                            createLeaseTable(conn);

                            conn.commit();

                            newTable = true;
                        } catch (Exception ine)
                        {
                            if (tc.isDebugEnabled())
                                Tr.debug(tc, "Table Creation failed with exception: " + ine);
                            // Set the current exception to ine
                            throw ine;
                        }
                    } // eof synchronize block
                } // eof isServerStartup
                else
                {
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, "Lease select update failed with exception: " + currentEx);
                    // Set the current exception to ine
                    throw currentEx;
                }
            }

            boolean needInsert = true;
            if (!newTable)
            {
                // We havent just created the table, see if we have a row to update
                if (lockingRS.next())
                {
                    // We found the Server row
                    long storedLease = lockingRS.getLong(1);
                    String storedLeaseOwner = lockingRS.getString(2);
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, "Acquired lock row, stored lease value is: " + storedLease + ", stored owner is: " + storedLeaseOwner);

                    // If this is startup, check whether lease has expired
                    if (isServerStartup)
                    {
                        PeerLeaseData pld = new PeerLeaseData(recoveryIdentity, storedLease, _leaseTimeout);
                        if (pld.isExpired())
                        {
                            if (tc.isDebugEnabled())
                                Tr.debug(tc, "Lease has expired, we should update lease and recover");
                            // We have acquired the lock. If any other server is also trying to peer recover then
                            // they can fail. To make this happen, we'll update the lease time ourselves.
                        }
                        else
                        {
                            // Lease has not expired, are we the owner or is some other server peer recovering
                            // If the latter, then we should barf
                            if (!storedLeaseOwner.equals(recoveryIdentity))
                            {
                                if (tc.isDebugEnabled())
                                    Tr.debug(tc, "A peer is recovering, we will fail our recovery and exit");
                                Object[] errorObject = new Object[] { recoveryIdentity };
                                RecoveryFailedException rex = new RecoveryFailedException();
                                throw rex;
                            }
                        }
                    }

                    // Construct the UPDATE string
                    String updateString = "UPDATE " + _leaseTableName +
                                          " SET LEASE_TIME = ?, RECOVERY_GROUP = ?, LEASE_OWNER = ?" +
                                          " WHERE SERVER_IDENTITY='" + recoveryIdentity + "'";
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, "update lease for " + recoveryIdentity);

                    updateStmt = conn.prepareStatement(updateString);
                    // Set the Lease_time to the current time
                    //TODO:
                    long fir1 = System.currentTimeMillis();
                    updateStmt.setLong(1, fir1);
                    updateStmt.setString(2, recoveryGroup);
                    updateStmt.setString(3, recoveryIdentity);
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, "Ready to UPDATE using string - " + updateString + " and time: " + fir1);
                    Tr.audit(tc, "WTRN0108I: Update Lease for server with recovery identity " + recoveryIdentity);

                    int ret = updateStmt.executeUpdate();

                    if (tc.isDebugEnabled())
                        Tr.debug(tc, "Have updated Server row with return: " + ret);
                    needInsert = false;
                }
                else
                {
                    // We didn't find the row in the table
                    //TODO: Should we insert a new one?
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, "Could not find row");
                }
            }

            // Either a new table or we couldn't find the row for our server. Insert it.
            if (needInsert)
            {
                // Insert a new row into the lease table
                insertNewLease(recoveryIdentity, recoveryGroup, conn);
            }
            if (tc.isDebugEnabled())
                Tr.debug(tc, "COMMIT the change");
            conn.commit();
        }
        // Catch and report an SQLException. In the finally block we'll determine whether the condition is transient or not.
        catch (SQLException sqlex)
        {
            if (tc.isDebugEnabled())
                Tr.debug(tc, "Lease update failed with exception: " + sqlex);
        } finally
        {
            if (lockingRS != null && !lockingRS.isClosed())
                lockingRS.close();
            if (lockingStmt != null && !lockingStmt.isClosed())
                lockingStmt.close();
            if (updateStmt != null && !updateStmt.isClosed())
                updateStmt.close();
            if (conn != null)
                conn.close();

        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "updateServerLease");
    }
166385
public final void setGeneratingDebug(boolean generatingDebug)
    {
        if (sealed) onSealedMutation();
        generatingDebugChanged = true;
        if (generatingDebug && getOptimizationLevel() > 0)
            setOptimizationLevel(0);
        this.generatingDebug = generatingDebug;
    }
506292
protected void debug(String message) {
		final Log log = getLog();
		if (log != null)
			log.debug(message);
	}
306951
public static void setDebugging(boolean debugging) {
        FuzzyLite.debugging = debugging;
        if (isLogging()) {
            logger.setLevel(debugging ? Level.FINE : Level.INFO);
        }
    }
246397
public function setDebug($debug)
    {
        //====================================================================//
        // Change Parameter State
        $this->debug = $debug;
        //====================================================================//
        // Delete Existing Debug Messages
        if ((0 == $debug) && isset($this->debug)) {
            $this->deb = array();
        }

        return true;
    }
1032240
public synchronized DebugServer startDebugServer(int port, int maxClients) {
        if (mDebugServer != null) {
            Log.e(TAG, "Debug server has already been started.");
            return mDebugServer;
        }

        mDebugServer = new DebugServer(this, port, maxClients);
        Threads.spawn(mDebugServer);
        return mDebugServer;
    }
219319
def set_debug(self, debug=1):
        
        self._check_if_ready()
        self.debug = debug
        self.main_loop.debug = debug
256191
public void updateTriggerDataMember(Boolean triggerDataMember) throws SecurityException {
	checkWriteAccess();
	boolean hasAccess = ConfigWebUtil.hasAccess(config, SecurityManager.TYPE_SETTING);
	if (!hasAccess) throw new SecurityException("no access to update trigger-data-member");

	Element scope = _getRootElement("component");
	scope.setAttribute("trigger-data-member", Caster.toString(triggerDataMember, ""));
    }
1310255
protected void debug(String msg, Object... args) {
        if (processingEnv.getOptions().containsKey("debug")) {
            messager.printMessage(NOTE, String.format(msg, args));
        }
    }
453254
public function setDebug($debug)
    {
        if ($this->handler) {
            throw new AlreadyBuildedException('The handler already builded.');
        }

        $this->debug = (bool) $debug;

        return $this;
    }
1008281
public void debug(String msg) {
        logHandler.debug(msg);
        if (debugStore != null) {
            debugStore.log(msg);
        }
    }
264585
public static function setIsDebug(bool $bool): void
    {
        if (self::isCliApp()) {
            self::$IS_DEBUG = $bool;
        } else {
            MSession::set(MCoreApplication::DEBUG, $bool);
        }
    }
294185
@Override
    public void debug(String message) {
        if(this.logger.isDebugEnabled()) {
            this.logger.debug(buildMessage(message));
        }
    }