EthanLogClient.h

/*
* If not stated otherwise in this file or this component's LICENSE file the
* following copyright and licenses apply:
*
* Copyright 2016 Sky UK
*
* 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.
*/
/*
 * File:   EthanLogClient.h
 *
 */
 
#ifndef ETHANLOGCLIENT_H
#define ETHANLOGCLIENT_H
 
#include "ContainerId.h"
 
#include <map>
#include <set>
#include <chrono>
#include <string>
#include <cstdint>
 
#include <sys/uio.h>
 
 
typedef struct sd_event sd_event;
typedef struct sd_event_source sd_event_source;
 
 
class EthanLogClient
{
public:
    EthanLogClient(sd_event *loop, ContainerId &&id, std::string &&name, int fd,
                   unsigned allowedLevels, unsigned rate, unsigned burstSize,
                   const std::string& memCgroupMountPoint);
    ~EthanLogClient();
 
    EthanLogClient(const EthanLogClient &other) = delete;
    EthanLogClient(EthanLogClient &&other) = delete;
 
    EthanLogClient &operator=(const EthanLogClient &other) = delete;
    EthanLogClient &operator=(EthanLogClient &&other) = delete;
 
    void setContainerPid(pid_t pid);
 
public:
    inline bool closed() const
    {
        return (mSource == nullptr);
    }
 
    inline ContainerId id() const
    {
        return mContainerId;
    }
 
public:
    static constexpr unsigned LOG_LEVEL_FATAL       = (0x1 << 0);
    static constexpr unsigned LOG_LEVEL_ERROR       = (0x1 << 1);
    static constexpr unsigned LOG_LEVEL_WARNING     = (0x1 << 2);
    static constexpr unsigned LOG_LEVEL_MILESTONE   = (0x1 << 3);
    static constexpr unsigned LOG_LEVEL_INFO        = (0x1 << 4);
    static constexpr unsigned LOG_LEVEL_DEBUG       = (0x1 << 5);
 
private:
    static int pipeFdHandler(sd_event_source *source, int fd,
                             uint32_t revents, void *userData);
 
    int pipeFdHandler(uint32_t revents);
 
    void processLogData();
    int processLogLevel(const char *field, ssize_t len, struct iovec *iov) const;
#if (AI_BUILD_TYPE == AI_DEBUG)
    int processPid(const char *field, ssize_t len, struct iovec *iov) const;
#endif
    int processTimestamp(const char *field, ssize_t len, struct iovec *iov) const;
    int processThreadName(const char *field, ssize_t len, struct iovec *iov) const;
    int processCodeFile(const char *field, ssize_t len, struct iovec *iov) const;
    int processCodeFunction(const char *field, ssize_t len, struct iovec *iov) const;
    int processCodeLine(const char *field, ssize_t len, struct iovec *iov) const;
    int processMessage(const char *field, ssize_t len, struct iovec *iov) const;
 
    bool shouldDrop();
 
#if (AI_BUILD_TYPE == AI_DEBUG)
    pid_t findRealPid(pid_t nsPid) const;
    std::set<pid_t> getAllContainerPids() const;
    pid_t readNsPidFromProc(pid_t pid) const;
#endif // (AI_BUILD_TYPE == AI_DEBUG)
 
    static constexpr ssize_t MAX_LOG_MSG_LENGTH = 512;
 
    static constexpr char RECORD_DELIM = '\x1e';
    static constexpr char FIELD_DELIM = '\x1f';
 
private:
    const ContainerId mContainerId;
    const std::string mName;
    const int mPipeFd;
    const unsigned mAllowedLevels;
 
    sd_event_source *mSource;
 
    std::string mIdentifier;
 
    char mMsgBuf[(MAX_LOG_MSG_LENGTH * 2)];
    size_t mMsgLen;
 
    bool mRateLimitingEnabled;
 
    struct TokenBucket
    {
        const unsigned int rate;
        const unsigned int burstSize;
 
        unsigned int tokens;
        std::chrono::steady_clock::time_point lastFill;
 
        TokenBucket(unsigned int rate_, unsigned int burstSize_)
            : rate(rate_)
            , burstSize(burstSize_)
            , tokens(0)
            , lastFill(std::chrono::steady_clock::time_point::min())
        { }
 
    } mTokenBucket;
 
    unsigned int mDropped;
    std::chrono::steady_clock::time_point mFirstDropped;
    std::chrono::steady_clock::time_point mLastDropped;
 
    std::string mDefaultObjectPid;
    std::string mDefaultSyslogPid;
 
    std::string mCgroupPidsPath;
    mutable std::map<pid_t, pid_t> mNsToRealPidMapping;
 
};
 
 
#endif // ETHANLOGCLIENT_H