精华内容
下载资源
问答
  • 请问有没什么方法可以限制文件大小,当达到指定大小,就新建文件继续打印日志信息 [b]问题补充:[/b] 哎,我用jbuilder开发。 程序早已写好,随意不太好吧! 就算可以用log4j,改起来也要费很多时间。 请问不用...
  • flink如果不限制日志文件大小,如果报错的情况下,会产生大文件日志。

    问题

    flink如果不限制日志文件大小,如果报错的情况下,会产生大文件日志。
    在这里插入图片描述

    说明

    Flink1.10.1,jm和tm日志输出在不同文件中。
    Flink1.11.1,jm和tm日志输出在同一个文件中。
    这两个版本,我们都可以对Flink日志做滚动的配置,控制每个日志文件的输出大小。

    配置详情

    jm 和 tm 上用的 log 配置都依赖于 flink/conf/log4j.properties 配置文件。
    下面两个版本,将滚动日志设置为最大5m,最多10个文件。

    Flink1.10.1

    # 滚动日志配置
    # This affects logging for both user code and Flink
    log4j.rootLogger=INFO, R
    
    # Uncomment this if you want to _only_ change Flink's logging
    #log4j.logger.org.apache.flink=INFO
    
    # The following lines keep the log level of common libraries/connectors on
    # log level INFO. The root logger does not override this. You have to manually
    # change the log levels here.
    log4j.logger.akka=INFO
    log4j.logger.org.apache.kafka=INFO
    log4j.logger.org.apache.hadoop=INFO
    log4j.logger.org.apache.zookeeper=INFO
    
    log4j.appender.R=org.apache.log4j.RollingFileAppender
    log4j.appender.R.File=${log.file}
    log4j.appender.R.MaxFileSize=5MB
    log4j.appender.R.Append=true
    log4j.appender.R.MaxBackupIndex=10
    log4j.appender.R.layout=org.apache.log4j.PatternLayout
    log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %t %-5p %-60c %x - %m%n
    
    # Suppress the irrelevant (wrong) warnings from the Netty channel handler
    log4j.logger.org.apache.flink.shaded.akka.org.jboss.netty.channel.DefaultChannelPipeline=ERROR, R
    
    

    Flink1.11.1

    # 滚动日志的配置
    # This affects logging for both user code and Flink
    rootLogger.level = DEBUG
    rootLogger.appenderRef.rolling.ref = RollingFileAppender
     
    # Uncomment this if you want to _only_ change Flink's logging
    #logger.flink.name = org.apache.flink
    #logger.flink.level = INFO
     
    # The following lines keep the log level of common libraries/connectors on
    # log level INFO. The root logger does not override this. You have to manually
    # change the log levels here.
    logger.akka.name = akka
    logger.akka.level = INFO
    logger.kafka.name= org.apache.kafka
    logger.kafka.level = INFO
    logger.hadoop.name = org.apache.hadoop
    logger.hadoop.level = INFO
    logger.zookeeper.name = org.apache.zookeeper
    logger.zookeeper.level = INFO
     
    # Log all infos in the given rolling file
    appender.rolling.name = RollingFileAppender
    appender.rolling.type = RollingFile
    appender.rolling.append = false
    #日志文件名
    appender.rolling.fileName = ${sys:log.file}
    #指定当发生文件滚动时,文件重命名规则
    appender.rolling.filePattern = ${sys:log.file}.%i
    appender.rolling.layout.type = PatternLayout
    # 输出模板
    appender.rolling.layout.pattern = %d{yyyy-MM-dd HH:mm:ss,SSS} %-5p %-60c %x - %m%n
    # 指定记录文件的保存策略,该策略主要是完成周期性的日志文件保存工作
    appender.rolling.policies.type = Policies
    # 基于日志文件大小的触发策略
    appender.rolling.policies.size.type = SizeBasedTriggeringPolicy
    # 当日志文件大小大于size指定的值时,触发滚动
    appender.rolling.policies.size.size = 5MB
    # 文件保存的覆盖策略
    appender.rolling.strategy.type = DefaultRolloverStrategy
    # 生成分割(保存)文件的个数,默认为5(-1,-2,-3,-4,-5)
    appender.rolling.strategy.max = 10
     
    # Suppress the irrelevant (wrong) warnings from the Netty channel handler
    logger.netty.name = org.apache.flink.shaded.akka.org.jboss.netty.channel.DefaultChannelPipeline
    logger.netty.level = OFF
    
    展开全文
  • 如何按日期生成apache日志文件限制apache日志文件大小
  •  1用一个INI配置文件管理日志目录,日志文件限制大小,特殊的日志名,特殊日志的大小限制。  2读取INI文件中的所有信息:每一个日志目录对应的大小限制,每一个特殊日志对应的大小限制。如特殊日志在既定的日志...

    设计思路:

      1 用一个INI配置文件管理日志目录,日志文件限制的大小,特殊的日志名,特殊日志的大小限制。

      2 读取INI文件中的所有信息:每一个日志目录对应的大小限制,每一个特殊日志对应的大小限制。如特殊日志在既定的日志目录中需去除。

      3 按设置的大小循环检测并清理每一个日志文件。

      4 监听有名管道的信号,如读取到了修改了INI文件的信号,则重新开始读取,循环。

    代码:

    LogSizeLimit.h

    #ifndef LOGSIZELIMIT_H_
    #define LOGSIZELIMIT_H_
    
    #include <map>
    #include <vector>
    #include <string.h>
    #include "GlobDefine.h"
    #include "Mutex.h"
    
    static const INT8 *IniFileName = "/LogService/LogSizeManage.ini";
    //static const UINT32 LogFileSizeDefault = 2 * 1024 * 1024;
    static const INT8 * LogFileSizeDefault = "2M";
    static const INT8 *LogPipeName = "/LogService/LOGSIZE.fifo";
    static const INT8 *ChangedStr = "changed";
    static const UINT32 CleanInterval = 4;
    static const UINT32 LogFilePathMaxLen = 64;
    static const UINT32 LogFileAttrMaxLen = 8;
    
    class LogSizeLimit {
    //    static Mutex mutex;
    public:
        LogSizeLimit(const string iniFile);
        ~LogSizeLimit();
        bool start();
        bool getChangeFlag() {
            return changeFlag;
        }
        void setChangeFlag(bool status) {
            changeFlag = status;
        }
    private:
        string _iniFile;
        map<string, string> _catelogAttr;
        map<string, string> _specialFileAttr;
    
        map<string, vector<string> > _logFiles;
        bool changeFlag;
    
        static void *run(void *args);
        static void *listenChanged(void*args);
        bool readConfig();
        bool limitLogFile();
    
        bool readFileList(const INT8 *mapStrPath, const INT8 *basePath);
        bool checkAndCleanLog(string logName, INT32 size);
        INT32 transSizeToBytes(const INT8 * size);
        bool readPipeMsg();
    };
    
    #endif /* LOGSIZELIMIT_H_ */

    LogSizeLimit.cpp

    #include <pthread.h>
    #include <unistd.h>
    #include <dirent.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include <errno.h>
    #include <fcntl.h>
    #include "LogSizeLimit.h"
    #include "IniConfigFile.h"
    #include "Logger.h"
    #include "FileOperation.h"
    using namespace FrameWork;
    
    LogSizeLimit::LogSizeLimit(const string iniFile) :
            _iniFile(iniFile), changeFlag(true) {
    }
    
    LogSizeLimit::~LogSizeLimit() {
    
    }
    
    bool LogSizeLimit::start() {
        pthread_t tid, changetid;
        pthread_create(&tid, NULL, run, (void*) this);
        pthread_create(&changetid, NULL, listenChanged, (void*) this);
        return true;
    }
    
    bool LogSizeLimit::readConfig() {
        //Clean map vars
        map<string, string>::iterator iter_tmp = _catelogAttr.begin();
        while (iter_tmp != _catelogAttr.end()) {
            _catelogAttr.erase(iter_tmp);
            iter_tmp++;
        }
        //Clean map vars
        iter_tmp = _specialFileAttr.begin();
        while (iter_tmp != _specialFileAttr.end()) {
            _specialFileAttr.erase(iter_tmp);
            iter_tmp++;
        }
        //Clean map vars
        map<string, vector<string> >::iterator mvIter_tmp = _logFiles.begin();
        while (mvIter_tmp != _logFiles.end()) {
            _logFiles.erase(mvIter_tmp);
            mvIter_tmp++;
        }
    
        if (!FileOperation::isExistFile(_iniFile)) {
            Logger::GetInstance().Fatal("Can not find ini file : %s !",
                    _iniFile.c_str());
            return false;
        }
        //Create ini file handling var.
        IniConfigFile iniSet(_iniFile.c_str());
    
        INT8 logPath[LogFilePathMaxLen] = { 0 };
        INT8 logFileAttr[LogFileAttrMaxLen] = { 0 };
    
        INT8 specialFile_1[LogFilePathMaxLen] = { 0 };
        INT8 specialFileAttr_1[LogFileAttrMaxLen] = { 0 };
    
        const INT8 *catelogBase = "catelog_";
        const INT8 *limitBase = "logSizeLimit_";
        const INT8 *specialFileBase = "specialFile_";
        const INT8 *specialLimitBase = "specialFileSizeLimit_";
    
        INT8 catelogCnt = '1';
        bool isExist = true;
    
        INT8 catelogIndex[32] = { 0 };
        INT8 logSizeIndex[32] = { 0 };
    
        while (isExist) {
    
            memset(catelogIndex, 0, 32);
            memset(logSizeIndex, 0, 32);
            memset(logPath, 0, LogFilePathMaxLen);
            memset(logFileAttr, 0, LogFileAttrMaxLen);
    
            memcpy(catelogIndex, catelogBase, strlen(catelogBase));
            memcpy(catelogIndex + strlen(catelogBase), &catelogCnt, 1);
            memcpy(logSizeIndex, limitBase, strlen(limitBase));
            memcpy(logSizeIndex + strlen(limitBase), &catelogCnt, 1);
    
            //section key value
            do {
                if (iniSet.readIniConfFile("LogSizeManage", catelogIndex, logPath,
                        LogFilePathMaxLen) != true) {
                    Logger::GetInstance().Error("Can not locate %s !",
                            catelogIndex);
                    isExist = false;
                    break;
                } else
                    Logger::GetInstance().Info("Get a catelog %s=%s !",
                            catelogIndex, logPath);
    
                if (iniSet.readIniConfFile("LogSizeManage", logSizeIndex,
                        logFileAttr, LogFilePathMaxLen) != true) {
                    Logger::GetInstance().Error(
                            "Can not get size %s, using default size %s !",
                            logSizeIndex, LogFileSizeDefault);
                    memcpy(logFileAttr, LogFileSizeDefault,
                            strlen(LogFileSizeDefault));
                } else
                    Logger::GetInstance().Info("Get a log size attr %s !",
                            logFileAttr);
    
                _catelogAttr[logPath] = logFileAttr;
                isExist = true;
                map<string, string>::iterator iter;
                iter = _catelogAttr.begin();
                for (UINT32 i = 1; i < _catelogAttr.size(); i++)
                    iter++;
                cout << "_catelogAttr_size : " << _catelogAttr.size() << " begin : "
                        << iter->first << " end : " << iter->second << endl;
    
            } while (0); // read the normal catelogs
    
            memset(catelogIndex, 0, 32);
            memset(logSizeIndex, 0, 32);
            memset(logPath, 0, LogFilePathMaxLen);
            memset(logFileAttr, 0, LogFileAttrMaxLen);
    
            memcpy(catelogIndex, specialFileBase, strlen(specialFileBase));
            memcpy(catelogIndex + strlen(specialFileBase), &catelogCnt, 1);
            memcpy(logSizeIndex, specialLimitBase, strlen(specialLimitBase));
            memcpy(logSizeIndex + strlen(specialLimitBase), &catelogCnt, 1);
    
            do {
                if (iniSet.readIniConfFile("LogSizeManage", catelogIndex, logPath,
                        LogFilePathMaxLen) != true) {
                    Logger::GetInstance().Error("Can not locate a special log %s !",
                            catelogIndex);
                    break;
                } else
                    Logger::GetInstance().Info("Get a special log %s=%s !",
                            catelogIndex, logPath);
    
                if (iniSet.readIniConfFile("LogSizeManage", logSizeIndex,
                        logFileAttr, LogFilePathMaxLen) != true) {
                    Logger::GetInstance().Error(
                            "Can not get log size %s, using default size %s !",
                            logFileAttr, LogFileSizeDefault);
                    memcpy(logFileAttr, LogFileSizeDefault,
                            strlen(LogFileSizeDefault));
    //                break;
                } else
                    Logger::GetInstance().Info("Get a special log size %s !",
                            logFileAttr);
                if (!isExist)
                    isExist = true;
    
                _specialFileAttr[logPath] = logFileAttr;
                map<string, string>::iterator iter;
                iter = _specialFileAttr.begin();
                cout << "_specialFileAttr_size : " << _specialFileAttr.size()
                        << " begin : " << iter->first << " end : " << iter->second
                        << endl;
            } while (0); // read the special log files
    
            catelogCnt++;
        } //while
    
        return true;
    }
    
    //struct dirent
    //{
    //   long d_ino; /* inode number 索引节点号 */
    //   off_t d_off; /* offset to this dirent 在目录文件中的偏移 */
    //   unsigned short d_reclen; /* length of this d_name 文件名长 */
    //   unsigned char d_type; /* the type of d_name 文件类型 */其中d_type表明该文件的类型:文件(8)、目录(4)、链接文件(10)等。
    //   char d_name [NAME_MAX+1]; /* file name (null-terminated) 文件名,最长255字符 */
    //}
    
    bool LogSizeLimit::readFileList(const INT8 *mapStrPath, const INT8 *basePath) {
        DIR *dir;
        struct dirent *direntPtr;
        char base[LogFilePathMaxLen] = { 0 };
    
        if ((dir = opendir(basePath)) == NULL) {
            Logger::GetInstance().Error("Can not open directory %s ! ", basePath);
            return false;
        }
    
        while ((direntPtr = readdir(dir)) != NULL) {
            if (strcmp(direntPtr->d_name, ".") == 0
                    || strcmp(direntPtr->d_name, "..") == 0) ///current dir OR parrent dir
                continue;
            else if (direntPtr->d_type == 8) {  ///file
                string fileName;
                fileName += basePath;
                if (basePath[strlen(basePath) - 1] != '/')
                    fileName += '/';
                fileName += direntPtr->d_name;
                _logFiles[mapStrPath].push_back(fileName);
            } else if (direntPtr->d_type == 10)    ///link file
                Logger::GetInstance().Info("A link file : %s !", direntPtr->d_name);
            else if (direntPtr->d_type == 4)    ///dir
                    {
                memset(base, '\0', sizeof(base));
                strcpy(base, basePath);
                if (base[strlen(base) - 1] != '/')
                    strcat(base, "/");
                strcat(base, direntPtr->d_name);
                readFileList(mapStrPath, base);
            }
        }
        closedir(dir);
        return true;
    }
    
    bool LogSizeLimit::limitLogFile() {
        changeFlag = true;
        map<string, string>::iterator mIter;
        for (mIter = _catelogAttr.begin(); mIter != _catelogAttr.end(); mIter++) {
            if (!FileOperation::isExisteDirectory(mIter->first)) {
                Logger::GetInstance().Fatal("Catelog %s is not existed !",
                        mIter->first.c_str());
            } else {
                Logger::GetInstance().Info("catelog %s is existed !",
                        mIter->first.c_str());
                readFileList(mIter->first.c_str(), mIter->first.c_str());
            }
        }
    
        //
        map<string, vector<string> >::iterator mvIter = _logFiles.begin();
        vector<string>::iterator vIter;
        bool deleteFlag = false;
        while (mvIter != _logFiles.end()) {
            vIter = mvIter->second.begin();
            while (vIter != mvIter->second.end()) {
                Logger::GetInstance().Info("Log file : %s : %s ",
                        mvIter->first.c_str(), vIter->c_str());
                mIter = _specialFileAttr.begin();
                for (; mIter != _specialFileAttr.end(); mIter++) {
                    deleteFlag = false;
                    //Remove the special log file from the normal catelog
                    if (strncmp(vIter->c_str(), mIter->first.c_str(),
                            strlen(vIter->c_str())) == 0) {
                        Logger::GetInstance().Info(
                                "Remove log file for special log : %s !",
                                vIter->c_str());
                        vIter = _logFiles[mvIter->first].erase(vIter);
                        deleteFlag = true;
                        break;
                    }
                }
                if (!deleteFlag)
                    vIter++;
            }
            mvIter++;
        }
    
        // Check change signal
        while (changeFlag) {
            mIter = _catelogAttr.begin();
            for (; mIter != _catelogAttr.end(); mIter++) {
                vIter = _logFiles[mIter->first].begin();
                for (; vIter != _logFiles[mIter->first].end(); vIter++) {
    //                cout << "log clean : " << *vIter << " size ; "
    //                        << transSizeToBytes(mIter->second.c_str()) << endl;
                    checkAndCleanLog(*vIter,
                            transSizeToBytes(mIter->second.c_str()));
                }
            }
    
            mIter = _specialFileAttr.begin();
            for (; mIter != _specialFileAttr.end(); mIter++) {
    //            cout << "special log clean : "<<mIter->first<<endl;
                checkAndCleanLog(mIter->first,
                        transSizeToBytes(mIter->second.c_str()));
            }
            sleep(CleanInterval);
        }
    
        return true;
    }
    
    bool LogSizeLimit::checkAndCleanLog(string logName, INT32 size) {
        struct stat statbuff;
        if (-1 == stat(logName.c_str(), &statbuff)) {
    //        Logger::GetInstance().Error("Can not Stat() log file %s !",
    //                logName.c_str());
            return false;
        }
    
        //Clean file
        if (statbuff.st_size >= size) {
            fstream fout(logName.c_str(), ios::out | ios::trunc);
            fout.close();
        }
        return true;
    }
    
    // Get bytes
    INT32 LogSizeLimit::transSizeToBytes(const INT8 * size) {
        if (size[strlen(size) - 1] == 'M' || size[strlen(size) - 1] == 'm') {
            INT8 msize[32] = { 0 };
            memcpy(msize, size, strlen(size) - 1);
            return atoi(msize) * 1024 * 1024;
        } else if (size[strlen(size) - 1] == 'K' || size[strlen(size) - 1] == 'k') {
            INT8 ksize[32] = { 0 };
            memcpy(ksize, size, strlen(size) - 1);
            return atoi(ksize) * 1024;
        } else {
            Logger::GetInstance().Error("Unknow size %s !", size);
            return 0;
        }
    }
    
    void *LogSizeLimit::run(void *args) {
        LogSizeLimit *logLimit = (LogSizeLimit*) args;
        do {
            logLimit->readConfig();
            logLimit->limitLogFile();
        } while (logLimit->getChangeFlag() == false);
    
        return NULL;
    }
    
    void *LogSizeLimit::listenChanged(void*args) {
        LogSizeLimit *logLimit = (LogSizeLimit*) args;
        logLimit->readPipeMsg();
        return NULL;
    }
    
    // Listen fifo signal
    bool LogSizeLimit::readPipeMsg() {
        INT8 buf_r[100];
        INT32 fd;
        INT32 nread;
    
        if ((mkfifo(LogPipeName, O_CREAT | O_EXCL) < 0) && (errno != EEXIST))
            Logger::GetInstance().Error("Can not create fifo server !");
    
        memset(buf_r, 0, sizeof(buf_r));
        fd = open(LogPipeName, O_RDONLY | O_NONBLOCK, 0);
        if (fd == -1) {
            Logger::GetInstance().Error("Can not open fifo %s for %s !",
                    LogPipeName, strerror(errno));
            return false;
        }
        while (1) {
            memset(buf_r, 0, sizeof(buf_r));
            if ((nread = read(fd, buf_r, 100)) == -1) {
                // if (errno == EAGAIN)
                // printf("no data yet\n");
            }
            if ((strncmp(buf_r, ChangedStr, strlen(ChangedStr))) == 0) {
                Logger::GetInstance().Info("Get changed cmd !");
                setChangeFlag(false);
            }
            sleep(2);
        }
        unlink(LogPipeName);
        return true;
    }

     

    使用 

    echo changed > /LogService/LOGSIZE.fifo

    可以使更新的INI配置立即生效。

    INI配置文件:

    [LogSizeManage]
    catelog_1=/nand/log/
    logSizeLimit_1=2M
    catelog_2=/var/log
    specialFile_1=/nand/log/App.log
    specialFileSizeLimit_1=4M

     

    转载于:https://www.cnblogs.com/bobojiang/p/9370110.html

    展开全文
  • 通常我们是在{$apache}/conf/httpd.conf中设置Apache...{$apache}/bin/目录下),来限制日志文件大小。 Usage: rotatelogs [-l] [offset minutes from UTC] or Add this: TransferLog “|rotatelogs /some/where 86400
  • 用到apache自带的rotatelogs小工具 语法如下: rotatelogs [ -l ] logfile [ rotationtime [ offset ]] | [ filesizeM ] 参数解释: ...-l :使用本地时间代替GMT时间作为时间...logfile:它加上基准名就是日志文件

    用到apache自带的rotatelogs小工具

    语法如下:
    rotatelogs [ -l ] logfile [ rotationtime [ offset ]] | [ filesizeM ]

    参数解释:
    -l :使用本地时间代替GMT时间作为时间基准。注意:在一个改变GMT偏移量(比如夏令时)的环境中使用-l会导致不可预料的结果。
    logfile:它加上基准名就是日志文件名。如果logfile中包含"%",则它会被视为用于strftime()的格式字符串;否则它会被自动加上以秒为单

    位的".nnnnnnnnnn"后缀。这两种格式都表示新的日志开始使用的时间。
    rotationtime :日志文件滚动的以秒为单位的间隔时间。
    offset :相对于UTC的时差的分钟数。如果省略,则假定为"0"并使用UTC时间。比如,要指定UTC时差为"-5小时"的地区的当地时间,则此参数

    应为"-300"。
    filesizeM :指定以filesizeM文件大小滚动,而不是按照时间或时差滚动。

    例子:
    1、按时间滚动日志文件:
    错误日志:ErrorLog "|/data/apache/bin/rotatelogs 日志存放目录/%Y%m%d_error.log 86400 480"
    访问日志:CustomLog "|/data/apache/bin/rotatelogs 日志存放目录/%Y%m%d_access.log 86400 480" common

    其中:
          /data/apache:为apache的安装目录,根据自己实际情况确定;
          86400:秒,24小时,表示生成的日志文件按天滚动,也就是每天生成一个日志文件;
          480:分,时间偏移。
    同理可以按小时滚动日志文件,每隔一个小时,几个小时。。。生成一个日志文件。

    扩展:可以写个脚本定时删除日志文件,只保留几天的日志,如果网站访问量比较大,一天会生成几十上百M甚至更大的日志文件,既占硬盘又影响服务器性能。

    2、按大小滚动日志文件:
    错误日志:ErrorLog "|/data/apache/bin/rotatelogs -l 日志存放目录/%Y%m%d_error.log 5M"
    访问日志:CustomLog "|/data/apache/bin/rotatelogs -l 日志存放目录/%Y%m%d_access.log 5M" common

    当日志文件达到5M时,滚动该日志文件。

    展开全文
  • 实际项目中经常会用到日志打印 为避免日志打印输出文件过大 消耗服务器内存 需要限制大小
  • 由于经常和数据库打交道,经常见到在客户的机器上,SQL server数据库日志文件大小,远远超过于数据库数据文件的大小,客户用的都是一些服务器,磁盘空间有的是,当然不在乎这点文件,可以,当客户要求查找一些数据的时候,...

    由于经常和数据库打交道,经常见到在客户的机器上,SQL server数据库日志文件的大小,远远超过于数据库数据文件的大小,客户用的都是一些服务器,磁盘空间有的是,当然不在乎这点文件,可以,当客户要求查找一些数据的时候,就不得不备份客户的数据库,经常是备份回来的数据库,无法还原,原因就是我的PC上没有这么大的空间来还原,无奈啊,

    只有把客户的数据库日志缩小一下了,于是从网上找了以下代码,可以收缩数据库日志,我执行了一下,日志缩小的,不过有一个错误产生,还没来的急分析,先不管他,达到目的才是硬道理

     


    SET NOCOUNT ON
    DECLARE @LogicalFileName sysname,
    @MaxMinutes INT,
    @NewSize INT


    USE bbbbb -- 要操作的数据库名
    SELECT @LogicalFileName = 'bbbbb_Log'-- 日志文件名
    @MaxMinutes = 100-- 数据库操作的超时上限.
    @NewSize = 100 -- 你想设定的日志文件的大小(M)

    -- Setup / initialize
    DECLARE @OriginalSize int
    SELECT @OriginalSize = size
    FROM sysfiles
    WHERE name = @LogicalFileName
    SELECT 'Original Size of ' + db_name() + ' LOG is ' +
    CONVERT(VARCHAR(30),@OriginalSize+ ' 8K pages or ' +
    CONVERT(VARCHAR(30),(@OriginalSize*8/1024)) + 'MB'
    FROM sysfiles
    WHERE name = @LogicalFileName
    CREATE TABLE DummyTrans
    (DummyColumn 
    char (8000not null)


    DECLARE @Counter INT,
    @StartTime DATETIME,
    @TruncLog VARCHAR(255)
    SELECT @StartTime = GETDATE(),
    @TruncLog = 'BACKUP LOG ' + db_name() + ' WITH TRUNCATE_ONLY'

    DBCC SHRINKFILE (@LogicalFileName@NewSize)
    EXEC (@TruncLog)
    -- Wrap the log if necessary.
    WHILE @MaxMinutes > DATEDIFF (mi, @StartTimeGETDATE()) -- 当操作未超时
    AND @OriginalSize = (SELECT size FROM sysfiles WHERE name = @LogicalFileNameAND (@OriginalSize * 8 /1024> @NewSize
    BEGIN -- Outer loop.
    SELECT @Counter = 0
    WHILE ((@Counter < @OriginalSize / 16AND (@Counter < 50000))
    BEGIN -- update
    INSERT DummyTrans VALUES ('Fill Log')
    DELETE DummyTrans
    SELECT @Counter = @Counter + 1
    END
    EXEC (@TruncLog)
    END
    SELECT 'Final Size of ' + db_name() + ' LOG is ' +
    CONVERT(VARCHAR(30),size) + ' 8K pages or ' +
    CONVERT(VARCHAR(30),(size*8/1024)) + 'MB'
    FROM sysfiles
    WHERE name = @LogicalFileName
    DROP TABLE DummyTrans
    SET NOCOUNT OFF
    展开全文
  • shell脚本限制日志文件大小和行数

    千次阅读 2018-10-05 17:11:18
    背景: 项目server在后端持续运行...将超出限制日志文件,先备份,再清空原日志文件内容。 清空日志文件内容的方法有:  1. echo "" &gt; test.log  2. cat /dev/null &gt; test.log  3....
  • 一、docker日志文件的方法 除了 docker logs -f 容器ID/容器名 这个方法以外。 在linux上,一般docker的日志文件存储在/var/lib/docker/containers/container_id/目录下的各个容器ID对应的目录下的*-json....
  • access.log,件在 WEB 服务器运行一段时间之后会达到几十兆甚至上百兆,如果Apache运行有错误,error.log也会增大到几十兆,我们知道系统读写一个大的文本文件是非常耗内存的,因此限定日志文件大小十分必要。...
  • 502 Bad Gateway nginx/1.1.0 公司CBS站点出现个别页面不能访问,查到下面解决办法,一查果然有个文件大于为2G。 需重启apache 明天再查是否...apache 日志文件超过大小限制,导致网站无法正常访问 (2009-11-05...
  • 限制为  5G 每次自动增长为 10M 方法一 : 使用 语句 修改 USE [master] GO ALTER DATABASE [DMS] MODIFY FILE ( NAME = N'DMS_log', MAXSIZE = 5120000KB , FILEGROWTH = 10240KB ) GO ALTER...
  • 限制错误日志文件为 1M ErrorLog “|bin/rotatelogs.exe -l logs/error-%Y-%m-%d.log 1M” 每天生成一个错误日志文件 #ErrorLog “|bin/rotatelogs.exe -l logs/error-%Y-%m-%d.log 86400” 限制访问日志文件为 1M ...
  • access.log,件在 WEB 服务器运行一段时间之后会达到几十兆甚至上百兆,如果Apache运行有错误,error.log也会增大到几十兆,我们知道系统读写一个大的文本文件是非常耗内存的,因此限定日志文件大小十分必要。...
  • 前段时间是APACHE日志过多,今天没事备份MSSQL数据库的时候,发现数据库日志文件也6G 多了哎… 这个叫一郁闷啊~创建数据库的时候忘记的了限制日志的大小了~(数据库不是我创建的哦~)解决办法: 进入企业管理器,...
  • 使用过 python 日志模块, 滚动设置很好用, 能限制日志文件数量 , 不至于长时间运行爆掉硬盘 . 网上找了一圈, 也没找到想要的结果, 有人还自己实现了限制文件数量…太麻烦了 最后自己试出来了, 分享一下: MyLog::...
  • 问题描述: ... 后续查阅资料,发现是因为docker中的某个进程一直在持续输出,而这些输出会记录到docker日志中,日志默认位置在/var/lib/docker/containers/containeid 目录下面的containeid-json.lo...
  • 日志大小、看看这些参数是否能达到你的目的:命令行参数–log-bin=filename:记录二进制日志文件的位置,尽量指定路径名,如果不指定的话则保存在数据目录;–log-bin-index=file:记录二进制日志文件索引的位置,保存了...
  • 1. 限制Apache日志文件大小的方法 -- rotatelog : http://www.java-cn.com/club/?uid-4-action-viewspace-itemid-622<br />2. 限制apache日志大小的... apache 日志文件超过大小限制,导致 网站无法正常访问:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 997
精华内容 398
关键字:

日志文件限制大小