diff --git a/metrics-ipmi-blobs/README.md b/metrics-ipmi-blobs/README.md
new file mode 100644
index 0000000..c9302eb
--- /dev/null
+++ b/metrics-ipmi-blobs/README.md
@@ -0,0 +1,13 @@
+IPMI BLOBs handler to export BMC metrics snapshot
+
+This BLOB handler registers one blob with the name "/metric/snapshot".
+
+The contents of the BLOB is a protocol buffer containing an instantaneous snapshot of the BMC's health metrics, which includes the following categories:
+
+1. BMC memory metric: mem_available, slab, kernel_stack
+2. Uptime: uptime in wall clock time, idle process across all cores
+3. Disk space: free space in RWFS in KiB
+4. Status of the top 10 processes: cmdline, utime, stime
+5. File descriptor of top 10 processes: cmdline, file descriptor count
+
+The size of the metrics are usually around 1KB to 1.5KB.
diff --git a/metrics-ipmi-blobs/handler.cpp b/metrics-ipmi-blobs/handler.cpp
new file mode 100644
index 0000000..46ac9cf
--- /dev/null
+++ b/metrics-ipmi-blobs/handler.cpp
@@ -0,0 +1,139 @@
+#include "handler.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace blobs
+{
+
+namespace
+{
+constexpr std::string_view metricPath("/metric/snapshot");
+} // namespace
+
+bool MetricBlobHandler::canHandleBlob(const std::string& path)
+{
+    return path == metricPath;
+}
+
+// A blob handler may have multiple Blobs. For this blob handler, there is only
+// one blob.
+std::vector<std::string> MetricBlobHandler::getBlobIds()
+{
+    return {std::string(metricPath)};
+}
+
+// BmcBlobDelete (7) is not supported.
+bool MetricBlobHandler::deleteBlob(const std::string& path)
+{
+    return false;
+}
+
+// BmcBlobStat (8) (global stat) is not supported.
+bool MetricBlobHandler::stat(const std::string& path, BlobMeta* meta)
+{
+    return false;
+}
+
+// Checks for a read-only flag.
+bool MetricBlobHandler::isReadOnlyOpenFlags(const uint16_t flags)
+{
+    if (((flags & blobs::OpenFlags::read) == blobs::OpenFlags::read) &&
+        ((flags & blobs::OpenFlags::write) == 0))
+    {
+        return true;
+    }
+    return false;
+}
+
+// BmcBlobOpen(2) handler.
+bool MetricBlobHandler::open(uint16_t session, uint16_t flags,
+                             const std::string& path)
+{
+    if (!isReadOnlyOpenFlags(flags))
+    {
+        return false;
+    }
+    if (!canHandleBlob(path))
+    {
+        return false;
+    }
+    if (path == metricPath)
+    {
+        std::unique_ptr<metric_blob::BmcHealthSnapshot> bhs =
+            std::make_unique<metric_blob::BmcHealthSnapshot>();
+        bhs.get()->doWork();
+        sessions[session] = nullptr;
+        sessions[session] = std::move(bhs);
+        return true;
+    }
+    return false;
+}
+
+// BmcBlobRead(3) handler.
+std::vector<uint8_t> MetricBlobHandler::read(uint16_t session, uint32_t offset,
+                                             uint32_t requestedSize)
+{
+    auto it = sessions.find(session);
+    if (it == sessions.end())
+    {
+        return {};
+    }
+
+    std::string_view result = it->second->read(offset, requestedSize);
+    return std::vector<uint8_t>(result.begin(), result.end());
+}
+
+// BmcBlobWrite(4) is not supported.
+bool MetricBlobHandler::write(uint16_t session, uint32_t offset,
+                              const std::vector<uint8_t>& data)
+{
+    return false;
+}
+
+// BmcBlobWriteMeta(10) is not supported.
+bool MetricBlobHandler::writeMeta(uint16_t session, uint32_t offset,
+                                  const std::vector<uint8_t>& data)
+{
+    return false;
+}
+
+// BmcBlobCommit(5) is not supported.
+bool MetricBlobHandler::commit(uint16_t session,
+                               const std::vector<uint8_t>& data)
+{
+    return false;
+}
+
+// BmcBlobClose(6) handler.
+bool MetricBlobHandler::close(uint16_t session)
+{
+    auto itr = sessions.find(session);
+    if (itr == sessions.end())
+    {
+        return false;
+    }
+    sessions.erase(itr);
+    return true;
+}
+
+// BmcBlobSessionStat(9) handler
+bool MetricBlobHandler::stat(uint16_t session, BlobMeta* meta)
+{
+    auto it = sessions.find(session);
+    if (it == sessions.end())
+    {
+        return false;
+    }
+    return it->second->stat(*meta);
+}
+
+bool MetricBlobHandler::expire(uint16_t session)
+{
+    return close(session);
+}
+
+} // namespace blobs
diff --git a/metrics-ipmi-blobs/handler.hpp b/metrics-ipmi-blobs/handler.hpp
new file mode 100644
index 0000000..d811333
--- /dev/null
+++ b/metrics-ipmi-blobs/handler.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <blobs-ipmid/blobs.hpp>
+#include <metric.hpp>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace blobs
+{
+
+class MetricBlobHandler : public GenericBlobInterface
+{
+  public:
+    MetricBlobHandler() = default;
+    ~MetricBlobHandler() = default;
+    MetricBlobHandler(const MetricBlobHandler&) = delete;
+    MetricBlobHandler& operator=(const MetricBlobHandler&) = delete;
+    MetricBlobHandler(MetricBlobHandler&&) = default;
+    MetricBlobHandler& operator=(MetricBlobHandler&&) = default;
+
+    bool canHandleBlob(const std::string& path) override;
+    std::vector<std::string> getBlobIds() override;
+    bool deleteBlob(const std::string& path) override;
+    bool stat(const std::string& path, BlobMeta* meta) override;
+    bool open(uint16_t session, uint16_t flags,
+              const std::string& path) override;
+    std::vector<uint8_t> read(uint16_t session, uint32_t offset,
+                              uint32_t requestedSize) override;
+    bool write(uint16_t session, uint32_t offset,
+               const std::vector<uint8_t>& data) override;
+    bool writeMeta(uint16_t session, uint32_t offset,
+                   const std::vector<uint8_t>& data) override;
+    bool commit(uint16_t session, const std::vector<uint8_t>& data) override;
+    bool close(uint16_t session) override;
+    bool stat(uint16_t session, BlobMeta* meta) override;
+    bool expire(uint16_t session) override;
+
+  private:
+    bool isReadOnlyOpenFlags(const uint16_t flag);
+    /* Every session gets its own BmcHealthSnapshot instance. */
+    std::unordered_map<uint16_t,
+                       std::unique_ptr<metric_blob::BmcHealthSnapshot>>
+        sessions;
+};
+
+} // namespace blobs
diff --git a/metrics-ipmi-blobs/main.cpp b/metrics-ipmi-blobs/main.cpp
new file mode 100644
index 0000000..ef09c46
--- /dev/null
+++ b/metrics-ipmi-blobs/main.cpp
@@ -0,0 +1,21 @@
+#include "handler.hpp"
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <memory>
+
+// Extern "C" is used due to the usage of dlopen() for loading IPMI handlers
+// and IPMI blob handlers. This happens in two steps:
+//
+// 1) ipmid loads all libraries in /usr/lib/ipmid-providers from its
+//    loadLibraries() function using dlopen().
+// 2) The blobs library, libblobcmds.so, loads all libraries in
+//    /usr/lib/blobs-ipmid from its loadLibraries() function. It uses dlsym()
+//    to locate the createHandler function by its un-mangled name
+//    "createHandler". Using extern "C" prevents its name from being mangled
+//    into, for example, "_Z13createHandlerv".
+
+extern "C" std::unique_ptr<blobs::GenericBlobInterface> createHandler()
+{
+    return std::make_unique<blobs::MetricBlobHandler>();
+}
diff --git a/metrics-ipmi-blobs/meson.build b/metrics-ipmi-blobs/meson.build
new file mode 100644
index 0000000..b3de2d8
--- /dev/null
+++ b/metrics-ipmi-blobs/meson.build
@@ -0,0 +1,44 @@
+project(
+  'metrics-ipmi-blobs',
+  'cpp',
+  version: '0.1',
+  default_options: [
+    'cpp_std=c++17',
+  ],
+)
+
+add_project_arguments(
+  '-Wno-unused-parameter',
+  language:'cpp')
+
+protoc = find_program('protoc', required: true)
+
+gen = generator(protoc,
+  output: [
+    '@BASENAME@.pb.cc', '@BASENAME@.pb.h'
+  ],
+  arguments : ['--proto_path=@CURRENT_SOURCE_DIR@', '--cpp_out=@BUILD_DIR@', '@INPUT@'])
+generated = gen.process(['metricblob.proto'])
+
+shared_library(
+  'metrics',
+  'main.cpp',
+  'handler.cpp',
+  'metric.cpp',
+  'util.cpp',
+  generated,
+  install: true,
+  install_dir: '/usr/lib/blob-ipmid/',
+  dependencies: [
+    dependency('phosphor-logging'),
+    dependency('phosphor-ipmi-blobs'),
+    dependency('protobuf'),
+  ],
+  version: '0',
+)
+
+gtest_dep = dependency('gtest')
+text_executable = executable('testprog', [
+    'test/util_test.cpp', 'util.cpp'],
+    dependencies: [ gtest_dep, dependency('phosphor-logging') ])
+test('gtest test', text_executable)
diff --git a/metrics-ipmi-blobs/metric.cpp b/metrics-ipmi-blobs/metric.cpp
new file mode 100644
index 0000000..afccc62
--- /dev/null
+++ b/metrics-ipmi-blobs/metric.cpp
@@ -0,0 +1,405 @@
+#include "metric.hpp"
+
+#include "metricblob.pb.h"
+
+#include "util.hpp"
+
+#include <sys/statvfs.h>
+
+#include <phosphor-logging/log.hpp>
+
+#include <cstdint>
+#include <filesystem>
+#include <sstream>
+#include <string>
+#include <string_view>
+
+namespace metric_blob
+{
+
+using phosphor::logging::entry;
+using phosphor::logging::log;
+using level = phosphor::logging::level;
+
+BmcHealthSnapshot::BmcHealthSnapshot() :
+    done(false), stringId(0), ticksPerSec(0)
+{}
+
+struct ProcStatEntry
+{
+    std::string cmdline;
+    std::string tcomm;
+    float utime;
+    float stime;
+
+    // Processes with the longest utime + stime are ranked first.
+    // Tie breaking is done with cmdline then tcomm.
+    bool operator<(const ProcStatEntry& other) const
+    {
+        const float negTime = -(utime + stime);
+        const float negOtherTime = -(other.utime + other.stime);
+        return std::tie(negTime, cmdline, tcomm) <
+               std::tie(negOtherTime, other.cmdline, other.tcomm);
+    }
+};
+
+bmcmetrics::metricproto::BmcProcStatMetric BmcHealthSnapshot::getProcStatList()
+{
+    constexpr std::string_view procPath = "/proc/";
+
+    bmcmetrics::metricproto::BmcProcStatMetric ret;
+    std::vector<ProcStatEntry> entries;
+
+    for (const auto& procEntry : std::filesystem::directory_iterator(procPath))
+    {
+        const std::string& path = procEntry.path();
+        int pid = -1;
+        if (isNumericPath(path, pid))
+        {
+            ProcStatEntry entry;
+
+            try
+            {
+                entry.cmdline = getCmdLine(pid);
+                TcommUtimeStime t = getTcommUtimeStime(pid, ticksPerSec);
+                entry.tcomm = t.tcomm;
+                entry.utime = t.utime;
+                entry.stime = t.stime;
+
+                entries.push_back(entry);
+            }
+            catch (const std::exception& e)
+            {
+                log<level::ERR>("Could not obtain process stats");
+            }
+        }
+    }
+
+    std::sort(entries.begin(), entries.end());
+
+    bool isOthers = false;
+    ProcStatEntry others;
+    others.cmdline = "(Others)";
+    others.utime = others.stime = 0;
+
+    // Only show this many processes and aggregate all remaining ones into
+    // "others" in order to keep the size of the snapshot reasonably small.
+    // With 10 process stat entries and 10 FD count entries, the size of the
+    // snapshot reaches around 1.5KiB. This is non-trivial, and we have to set
+    // the collection interval long enough so as not to over-stress the IPMI
+    // interface and the data collection service. The value of 10 is chosen
+    // empirically, it might be subject to adjustments when the system is
+    // launched later.
+    constexpr int topN = 10;
+
+    for (size_t i = 0; i < entries.size(); ++i)
+    {
+        if (i >= topN)
+        {
+            isOthers = true;
+        }
+
+        ProcStatEntry& entry = entries[i];
+
+        if (isOthers)
+        {
+            others.utime += entry.utime;
+            others.stime += entry.stime;
+        }
+        else
+        {
+            bmcmetrics::metricproto::BmcProcStatMetric::BmcProcStat s;
+            std::string fullCmdline = entry.cmdline;
+            if (entry.tcomm.size() > 0)
+            {
+                fullCmdline += " " + entry.tcomm;
+            }
+            s.set_sidx_cmdline(getStringID(fullCmdline));
+            s.set_utime(entry.utime);
+            s.set_stime(entry.stime);
+            *(ret.add_stats()) = s;
+        }
+    }
+
+    if (isOthers)
+    {
+        bmcmetrics::metricproto::BmcProcStatMetric::BmcProcStat s;
+        s.set_sidx_cmdline(getStringID(others.cmdline));
+        s.set_utime(others.utime);
+        s.set_stime(others.stime);
+        *(ret.add_stats()) = s;
+    }
+
+    return ret;
+}
+
+int getFdCount(int pid)
+{
+    const std::string& fdPath = "/proc/" + std::to_string(pid) + "/fd";
+    return std::distance(std::filesystem::directory_iterator(fdPath),
+                         std::filesystem::directory_iterator{});
+}
+
+struct FdStatEntry
+{
+    int fdCount;
+    std::string cmdline;
+    std::string tcomm;
+
+    // Processes with the largest fdCount goes first.
+    // Tie-breaking using cmdline then tcomm.
+    bool operator<(const FdStatEntry& other) const
+    {
+        const int negFdCount = -fdCount;
+        const int negOtherFdCount = -other.fdCount;
+        return std::tie(negFdCount, cmdline, tcomm) <
+               std::tie(negOtherFdCount, other.cmdline, other.tcomm);
+    }
+};
+
+bmcmetrics::metricproto::BmcFdStatMetric BmcHealthSnapshot::getFdStatList()
+{
+    bmcmetrics::metricproto::BmcFdStatMetric ret;
+
+    // Sort by fd count, no tie-breaking
+    std::vector<FdStatEntry> entries;
+
+    const std::string_view procPath = "/proc/";
+    for (const auto& procEntry : std::filesystem::directory_iterator(procPath))
+    {
+        const std::string& path = procEntry.path();
+        int pid = 0;
+        FdStatEntry entry;
+        if (isNumericPath(path, pid))
+        {
+            try
+            {
+                entry.fdCount = getFdCount(pid);
+                TcommUtimeStime t = getTcommUtimeStime(pid, ticksPerSec);
+                entry.cmdline = getCmdLine(pid);
+                entry.tcomm = t.tcomm;
+                entries.push_back(entry);
+            }
+            catch (const std::exception& e)
+            {
+                log<level::ERR>("Could not get file descriptor stats");
+            }
+        }
+    }
+
+    std::sort(entries.begin(), entries.end());
+
+    bool isOthers = false;
+
+    // Only report the detailed fd count and cmdline for the top 10 entries,
+    // and collapse all others into "others".
+    constexpr int topN = 10;
+
+    FdStatEntry others;
+    others.cmdline = "(Others)";
+    others.fdCount = 0;
+
+    for (size_t i = 0; i < entries.size(); ++i)
+    {
+        if (i >= topN)
+        {
+            isOthers = true;
+        }
+
+        const FdStatEntry& entry = entries[i];
+        if (isOthers)
+        {
+            others.fdCount += entry.fdCount;
+        }
+        else
+        {
+            bmcmetrics::metricproto::BmcFdStatMetric::BmcFdStat s;
+            std::string fullCmdline = entry.cmdline;
+            if (entry.tcomm.size() > 0)
+            {
+                fullCmdline += " " + entry.tcomm;
+            }
+            s.set_sidx_cmdline(getStringID(fullCmdline));
+            s.set_fd_count(entry.fdCount);
+            *(ret.add_stats()) = s;
+        }
+    }
+
+    if (isOthers)
+    {
+        bmcmetrics::metricproto::BmcFdStatMetric::BmcFdStat s;
+        s.set_sidx_cmdline(getStringID(others.cmdline));
+        s.set_fd_count(others.fdCount);
+        *(ret.add_stats()) = s;
+    }
+
+    return ret;
+}
+
+void BmcHealthSnapshot::serializeSnapshotToArray(
+    const bmcmetrics::metricproto::BmcMetricSnapshot& snapshot)
+{
+    size_t size = snapshot.ByteSizeLong();
+    if (size > 0)
+    {
+        pbDump.resize(size);
+        if (!snapshot.SerializeToArray(pbDump.data(), size))
+        {
+            log<level::ERR>("Could not serialize protobuf to array");
+        }
+    }
+}
+
+void BmcHealthSnapshot::doWork()
+{
+    bmcmetrics::metricproto::BmcMetricSnapshot snapshot;
+
+    // Memory info
+    std::string meminfoBuffer = readFileIntoString("/proc/meminfo");
+
+    {
+        bmcmetrics::metricproto::BmcMemoryMetric m;
+
+        std::string_view sv(meminfoBuffer.data());
+        // MemAvailable
+        int value;
+        bool ok = parseMeminfoValue(sv, "MemAvailable:", value);
+        if (ok)
+        {
+            m.set_mem_available(value);
+        }
+
+        ok = parseMeminfoValue(sv, "Slab:", value);
+        if (ok)
+        {
+            m.set_slab(value);
+        }
+
+        ok = parseMeminfoValue(sv, "KernelStack:", value);
+        if (ok)
+        {
+            m.set_kernel_stack(value);
+        }
+
+        *(snapshot.mutable_memory_metric()) = m;
+    }
+
+    // Uptime
+    std::string uptimeBuffer = readFileIntoString("/proc/uptime");
+    double uptime = 0, idleProcessTime = 0;
+    if (parseProcUptime(uptimeBuffer, uptime, idleProcessTime))
+    {
+        bmcmetrics::metricproto::BmcUptimeMetric m1;
+        m1.set_uptime(uptime);
+        m1.set_idle_process_time(idleProcessTime);
+        *(snapshot.mutable_uptime_metric()) = m1;
+    }
+    else
+    {
+        log<level::ERR>("Error parsing /proc/uptime");
+    }
+
+    // Storage space
+    struct statvfs fiData;
+    if ((statvfs("/", &fiData)) < 0)
+    {
+        log<level::ERR>("Could not call statvfs");
+    }
+    else
+    {
+        uint64_t kib = (fiData.f_bsize * fiData.f_bfree) / 1024;
+        bmcmetrics::metricproto::BmcDiskSpaceMetric m2;
+        m2.set_rwfs_kib_available(static_cast<int>(kib));
+        *(snapshot.mutable_storage_space_metric()) = m2;
+    }
+
+    // The next metrics require a sane ticks_per_sec value, typically 100 on
+    // the BMC. In the very rare circumstance when it's 0, exit early and return
+    // a partially complete snapshot (no process).
+    ticksPerSec = getTicksPerSec();
+
+    // FD stat
+    *(snapshot.mutable_fdstat_metric()) = getFdStatList();
+
+    if (ticksPerSec == 0)
+    {
+        log<level::ERR>("ticksPerSec is 0, skipping the process list metric");
+        serializeSnapshotToArray(snapshot);
+        done = true;
+        return;
+    }
+
+    // Proc stat
+    *(snapshot.mutable_procstat_metric()) = getProcStatList();
+
+    // String table
+    std::vector<std::string_view> strings(stringTable.size());
+    for (const auto& [s, i] : stringTable)
+    {
+        strings[i] = s;
+    }
+
+    bmcmetrics::metricproto::BmcStringTable st;
+    for (size_t i = 0; i < strings.size(); ++i)
+    {
+        bmcmetrics::metricproto::BmcStringTable::StringEntry entry;
+        entry.set_value(strings[i].data());
+        *(st.add_entries()) = entry;
+    }
+    *(snapshot.mutable_string_table()) = st;
+
+    // Save to buffer
+    serializeSnapshotToArray(snapshot);
+    done = true;
+}
+
+// BmcBlobSessionStat (9) but passing meta as reference instead of pointer,
+// since the metadata must not be null at this point.
+bool BmcHealthSnapshot::stat(blobs::BlobMeta& meta)
+{
+    if (!done)
+    {
+        // Bits 8~15 are blob-specific state flags.
+        // For this blob, bit 8 is set when metric collection is still in
+        // progress.
+        meta.blobState |= (1 << 8);
+    }
+    else
+    {
+        meta.blobState = 0;
+        meta.blobState = blobs::StateFlags::open_read;
+        meta.size = pbDump.size();
+    }
+    return true;
+}
+
+std::string_view BmcHealthSnapshot::read(uint32_t offset,
+                                         uint32_t requestedSize)
+{
+    uint32_t size = static_cast<uint32_t>(pbDump.size());
+    if (offset >= size)
+    {
+        return {};
+    }
+    return std::string_view(pbDump.data() + offset,
+                            std::min(requestedSize, size - offset));
+}
+
+int BmcHealthSnapshot::getStringID(const std::string_view s)
+{
+    int ret = 0;
+    auto itr = stringTable.find(s.data());
+    if (itr == stringTable.end())
+    {
+        stringTable[s.data()] = stringId;
+        ret = stringId;
+        ++stringId;
+    }
+    else
+    {
+        ret = itr->second;
+    }
+    return ret;
+}
+
+} // namespace metric_blob
\ No newline at end of file
diff --git a/metrics-ipmi-blobs/metric.hpp b/metrics-ipmi-blobs/metric.hpp
new file mode 100644
index 0000000..5d0d49e
--- /dev/null
+++ b/metrics-ipmi-blobs/metric.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "metricblob.pb.h"
+
+#include <unistd.h>
+
+#include <blobs-ipmid/blobs.hpp>
+
+#include <atomic>
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace metric_blob
+{
+
+class BmcHealthSnapshot
+{
+  public:
+    BmcHealthSnapshot();
+
+    /**
+     * Reads data from this metric
+     * @param offset: offset into the data to read
+     * @param requestedSize: how many bytes to read
+     * @returns Bytes able to read. Returns empty if nothing can be read.
+     */
+    std::string_view read(uint32_t offset, uint32_t requestedSize);
+
+    /**
+     * Returns information about the amount of readable data and whether the
+     * metric has finished populating.
+     * @param meta: Struct to fill with the metadata info
+     */
+    bool stat(blobs::BlobMeta& meta);
+
+    /**
+     * Start the metric collection process
+     */
+    void doWork();
+
+    /**
+     * The size of the content string.
+     */
+    uint32_t size();
+
+  private:
+    /**
+     * Serialize to the pb_dump_ array.
+     */
+    void serializeSnapshotToArray(
+        const bmcmetrics::metricproto::BmcMetricSnapshot& snapshot);
+
+    // The two following functions access the snapshot's string table so they
+    // have to be member functions.
+    bmcmetrics::metricproto::BmcProcStatMetric getProcStatList();
+    bmcmetrics::metricproto::BmcFdStatMetric getFdStatList();
+
+    int getStringID(const std::string_view s);
+    std::atomic<bool> done;
+    std::vector<char> pbDump;
+    std::unordered_map<std::string, int> stringTable;
+    int stringId;
+    long ticksPerSec;
+};
+
+} // namespace metric_blob
diff --git a/metrics-ipmi-blobs/metricblob.proto b/metrics-ipmi-blobs/metricblob.proto
new file mode 100644
index 0000000..6cf6223
--- /dev/null
+++ b/metrics-ipmi-blobs/metricblob.proto
@@ -0,0 +1,52 @@
+syntax = "proto3";
+
+package bmcmetrics.metricproto;
+
+message BmcMemoryMetric {
+  int32 mem_available = 1;
+  int32 slab = 2;
+  int32 kernel_stack = 3;
+}
+
+message BmcUptimeMetric {
+  float uptime = 1;             // Uptime (wall clock time)
+  float idle_process_time = 2;  // Idle process time across all cores
+}
+
+message BmcDiskSpaceMetric {
+  int32 rwfs_kib_available = 1;  // Free space in RWFS in KiB
+}
+
+// The following messages use string tables to save space
+message BmcProcStatMetric {
+  message BmcProcStat {
+    int32 sidx_cmdline = 1;  // complete command line
+    float utime = 2;         // Time (seconds) in user mode
+    float stime = 3;         // Time (seconds) in kernel mode
+  }
+  repeated BmcProcStat stats = 10;
+}
+
+message BmcFdStatMetric {
+  message BmcFdStat {
+    int32 sidx_cmdline = 1;  // complete command line
+    int32 fd_count = 2;      // count of open FD's
+  }
+  repeated BmcFdStat stats = 10;
+}
+
+message BmcStringTable {
+  message StringEntry {
+    string value = 1;
+  }
+  repeated StringEntry entries = 10;
+}
+
+message BmcMetricSnapshot {
+  BmcStringTable string_table = 1;
+  BmcMemoryMetric memory_metric = 2;
+  BmcUptimeMetric uptime_metric = 3;
+  BmcDiskSpaceMetric storage_space_metric = 4;
+  BmcProcStatMetric procstat_metric = 5;
+  BmcFdStatMetric fdstat_metric = 6;
+}
diff --git a/metrics-ipmi-blobs/subprojects b/metrics-ipmi-blobs/subprojects
new file mode 120000
index 0000000..15858bc
--- /dev/null
+++ b/metrics-ipmi-blobs/subprojects
@@ -0,0 +1 @@
+../subprojects
\ No newline at end of file
diff --git a/metrics-ipmi-blobs/test/util_test.cpp b/metrics-ipmi-blobs/test/util_test.cpp
new file mode 100644
index 0000000..9b45502
--- /dev/null
+++ b/metrics-ipmi-blobs/test/util_test.cpp
@@ -0,0 +1,143 @@
+#include "util.hpp"
+
+#include <filesystem>
+#include <fstream>
+
+#include "gtest/gtest.h"
+
+TEST(IsNumericPath, invalidNumericPath)
+{
+    std::string badPath{"badNumericPath"};
+    int id = -1;
+    EXPECT_FALSE(metric_blob::isNumericPath(badPath, id));
+    EXPECT_EQ(id, -1);
+}
+
+TEST(IsNumericPath, validNumericPath)
+{
+    std::string goodPath{"proc/10000"};
+    int id = -1;
+    EXPECT_TRUE(metric_blob::isNumericPath(goodPath, id));
+    EXPECT_EQ(id, 10000);
+}
+
+TEST(ReadFileIntoString, goodFile)
+{
+    const std::string& fileName = "./test_file";
+    std::ofstream ofs(fileName, std::ios::trunc);
+    std::string_view content = "This is\ntest\tcontentt\n\n\n\n.\n\n##$#$";
+    ofs << content;
+    ofs.close();
+    std::string readContent = metric_blob::readFileIntoString(fileName);
+    std::filesystem::remove(fileName);
+    EXPECT_EQ(readContent, content);
+}
+
+TEST(ReadFileIntoString, inexistentFile)
+{
+    const std::string& fileName = "./inexistent_file";
+    std::string readContent = metric_blob::readFileIntoString(fileName);
+    EXPECT_EQ(readContent, "");
+}
+
+TEST(GetTcommUtimeStime, validInput)
+{
+    // ticks_per_sec is usually 100 on the BMC
+    const long ticksPerSec = 100;
+
+    const std::string_view content = "2596 (dbus-broker) R 2577 2577 2577 0 -1 "
+                                     "4194560 299 0 1 0 333037 246110 0 0 20 0 "
+                                     "1 0 1545 3411968 530 4294967295 65536 "
+                                     "246512 2930531712 0 0 0 81923 4";
+
+    metric_blob::TcommUtimeStime t =
+        metric_blob::parseTcommUtimeStimeString(content, ticksPerSec);
+    const float EPS = 0.01; // The difference was 0.000117188
+    EXPECT_LT(std::abs(t.utime - 3330.37), EPS);
+    EXPECT_LT(std::abs(t.stime - 2461.10), EPS);
+    EXPECT_EQ(t.tcomm, "(dbus-broker)");
+}
+
+TEST(GetTcommUtimeStime, invalidInput)
+{
+    // ticks_per_sec is usually 100 on the BMC
+    const long ticksPerSec = 100;
+
+    const std::string_view content =
+        "x invalid x x x x x x x x x x x x x x x x x x x x x x x x x x x";
+
+    metric_blob::TcommUtimeStime t =
+        metric_blob::parseTcommUtimeStimeString(content, ticksPerSec);
+
+    EXPECT_EQ(t.utime, 0);
+    EXPECT_EQ(t.stime, 0);
+    EXPECT_EQ(t.tcomm, "invalid");
+}
+
+TEST(ParseMeminfoValue, validInput)
+{
+    const std::string_view content = "MemTotal:        1027040 kB\n"
+                                     "MemFree:          868144 kB\n"
+                                     "MemAvailable:     919308 kB\n"
+                                     "Buffers:           13008 kB\n"
+                                     "Cached:            82840 kB\n"
+                                     "SwapCached:            0 kB\n"
+                                     "Active:            62076 kB\n";
+    int value;
+    EXPECT_TRUE(metric_blob::parseMeminfoValue(content, "MemTotal:", value));
+    EXPECT_EQ(value, 1027040);
+    EXPECT_TRUE(metric_blob::parseMeminfoValue(content, "MemFree:", value));
+    EXPECT_EQ(value, 868144);
+    EXPECT_TRUE(
+        metric_blob::parseMeminfoValue(content, "MemAvailable:", value));
+    EXPECT_EQ(value, 919308);
+    EXPECT_TRUE(metric_blob::parseMeminfoValue(content, "Buffers:", value));
+    EXPECT_EQ(value, 13008);
+    EXPECT_TRUE(metric_blob::parseMeminfoValue(content, "Cached:", value));
+    EXPECT_EQ(value, 82840);
+    EXPECT_TRUE(metric_blob::parseMeminfoValue(content, "SwapCached:", value));
+    EXPECT_EQ(value, 0);
+    EXPECT_TRUE(metric_blob::parseMeminfoValue(content, "Active:", value));
+    EXPECT_EQ(value, 62076);
+}
+
+TEST(ParseMeminfoValue, invalidInput)
+{
+    const std::string_view invalid = "MemTotal: 1";
+    int value = -999;
+    EXPECT_FALSE(metric_blob::parseMeminfoValue(invalid, "MemTotal:", value));
+    EXPECT_EQ(value, -999);
+    EXPECT_FALSE(metric_blob::parseMeminfoValue(invalid, "x", value));
+    EXPECT_EQ(value, -999);
+}
+
+TEST(ParseProcUptime, validInput)
+{
+    const std::string_view content = "266923.67 512184.95";
+    const double eps =
+        1e-4; // Empirical threshold for floating point number compare
+    double uptime, idleProcessTime;
+    EXPECT_EQ(metric_blob::parseProcUptime(content, uptime, idleProcessTime),
+              true);
+    EXPECT_LT(abs(uptime - 266923.67), eps);
+    EXPECT_LT(abs(idleProcessTime - 512184.95), eps);
+}
+
+TEST(TrimStringRight, nonEmptyResult)
+{
+    EXPECT_EQ(
+        metric_blob::trimStringRight("\n\nabc\n\t\r\x00\x01\x02\x03").size(),
+        5); // "\n\nabc" is left
+}
+
+TEST(TrimStringRight, trimToEmpty)
+{
+    EXPECT_TRUE(metric_blob::trimStringRight("    ").empty());
+    EXPECT_TRUE(metric_blob::trimStringRight("").empty());
+}
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
\ No newline at end of file
diff --git a/metrics-ipmi-blobs/util.cpp b/metrics-ipmi-blobs/util.cpp
new file mode 100644
index 0000000..6096d51
--- /dev/null
+++ b/metrics-ipmi-blobs/util.cpp
@@ -0,0 +1,209 @@
+#include "util.hpp"
+
+#include <unistd.h>
+
+#include <phosphor-logging/log.hpp>
+
+#include <cmath>
+#include <cstdlib>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <string_view>
+
+namespace metric_blob
+{
+
+using phosphor::logging::log;
+using level = phosphor::logging::level;
+
+char controlCharsToSpace(char c)
+{
+    if (c < 32)
+    {
+        c = ' ';
+    }
+    return c;
+}
+
+long getTicksPerSec()
+{
+    return sysconf(_SC_CLK_TCK);
+}
+
+std::string readFileIntoString(const std::string_view fileName)
+{
+    std::stringstream ss;
+    std::ifstream ifs(fileName.data());
+    while (ifs.good())
+    {
+        std::string line;
+        std::getline(ifs, line);
+        ss << line;
+        if (ifs.good())
+            ss << std::endl;
+    }
+    return ss.str();
+}
+
+bool isNumericPath(const std::string_view path, int& value)
+{
+    size_t p = path.rfind('/');
+    if (p == std::string::npos)
+    {
+        return false;
+    }
+    int id = 0;
+    for (size_t i = p + 1; i < path.size(); ++i)
+    {
+        const char ch = path[i];
+        if (ch < '0' || ch > '9')
+            return false;
+        else
+        {
+            id = id * 10 + (ch - '0');
+        }
+    }
+    value = id;
+    return true;
+}
+
+// Trims all control characters at the end of a string.
+std::string trimStringRight(std::string_view s)
+{
+    std::string ret(s.data());
+    while (!ret.empty())
+    {
+        if (ret.back() <= 32)
+            ret.pop_back();
+        else
+            break;
+    }
+    return ret;
+}
+
+std::string getCmdLine(const int pid)
+{
+    const std::string& cmdlinePath =
+        "/proc/" + std::to_string(pid) + "/cmdline";
+
+    std::string cmdline = readFileIntoString(cmdlinePath);
+    for (size_t i = 0; i < cmdline.size(); ++i)
+    {
+        cmdline[i] = controlCharsToSpace(cmdline[i]);
+    }
+
+    // Trim empty strings
+    cmdline = trimStringRight(cmdline);
+
+    return cmdline;
+}
+
+// strtok is used in this function in order to avoid usage of <sstream>.
+// However, that would require us to create a temporary std::string.
+TcommUtimeStime parseTcommUtimeStimeString(std::string_view content,
+                                           const long ticksPerSec)
+{
+    TcommUtimeStime ret;
+    ret.tcomm = "";
+    ret.utime = ret.stime = 0;
+
+    const float invTicksPerSec = 1.0f / static_cast<float>(ticksPerSec);
+
+    // pCol now points to the first part in content after content is split by
+    // space.
+    // This is not ideal,
+    std::string temp(content);
+    char* pCol = strtok(temp.data(), " ");
+
+    if (pCol != nullptr)
+    {
+        const int fields[] = {1, 13, 14}; // tcomm, utime, stime
+        int fieldIdx = 0;
+        for (int colIdx = 0; colIdx < 15; ++colIdx)
+        {
+            if (fieldIdx < 3 && colIdx == fields[fieldIdx])
+            {
+                switch (fieldIdx)
+                {
+                    case 0:
+                    {
+                        ret.tcomm = std::string(pCol);
+                        break;
+                    }
+                    case 1:
+                        [[fallthrough]];
+                    case 2:
+                    {
+                        int ticks = std::atoi(pCol);
+                        float t = static_cast<float>(ticks) * invTicksPerSec;
+
+                        if (fieldIdx == 1)
+                        {
+                            ret.utime = t;
+                        }
+                        else if (fieldIdx == 2)
+                        {
+                            ret.stime = t;
+                        }
+                        break;
+                    }
+                }
+                ++fieldIdx;
+            }
+            pCol = strtok(nullptr, " ");
+        }
+    }
+
+    if (ticksPerSec <= 0)
+    {
+        log<level::ERR>("ticksPerSec is equal or less than zero");
+    }
+
+    return ret;
+}
+
+TcommUtimeStime getTcommUtimeStime(const int pid, const long ticksPerSec)
+{
+    const std::string& statPath = "/proc/" + std::to_string(pid) + "/stat";
+    return parseTcommUtimeStimeString(readFileIntoString(statPath),
+                                      ticksPerSec);
+}
+
+// Returns true if successfully parsed and false otherwise. If parsing was
+// successful, value is set accordingly.
+// Input: "MemAvailable:      1234 kB"
+// Returns true, value set to 1234
+bool parseMeminfoValue(const std::string_view content,
+                       const std::string_view keyword, int& value)
+{
+    size_t p = content.find(keyword);
+    if (p != std::string::npos)
+    {
+        std::string_view v = content.substr(p + keyword.size());
+        p = v.find("kB");
+        if (p != std::string::npos)
+        {
+            v = v.substr(0, p);
+            value = std::atoi(v.data());
+            return true;
+        }
+    }
+    return false;
+}
+
+bool parseProcUptime(const std::string_view content, double& uptime,
+                     double& idleProcessTime)
+{
+    double t0, t1; // Attempts to parse uptime and idleProcessTime
+    int ret = sscanf(content.data(), "%lf %lf", &t0, &t1);
+    if (ret == 2 && std::isfinite(t0) && std::isfinite(t1))
+    {
+        uptime = t0;
+        idleProcessTime = t1;
+        return true;
+    }
+    return false;
+}
+
+} // namespace metric_blob
\ No newline at end of file
diff --git a/metrics-ipmi-blobs/util.hpp b/metrics-ipmi-blobs/util.hpp
new file mode 100644
index 0000000..b74b589
--- /dev/null
+++ b/metrics-ipmi-blobs/util.hpp
@@ -0,0 +1,33 @@
+#ifndef _UTIL_HPP_
+#define _UTIL_HPP_
+
+#include <string>
+#include <string_view>
+
+namespace metric_blob
+{
+
+struct TcommUtimeStime
+{
+    std::string tcomm;
+    float utime;
+    float stime;
+};
+
+TcommUtimeStime parseTcommUtimeStimeString(std::string_view content,
+                                           long ticksPerSec);
+std::string readFileIntoString(std::string_view fileName);
+bool isNumericPath(std::string_view path, int& value);
+TcommUtimeStime getTcommUtimeStime(int pid, long ticksPerSec);
+std::string getCmdLine(int pid);
+bool parseMeminfoValue(std::string_view content, std::string_view keyword,
+                       int& value);
+bool parseProcUptime(const std::string_view content, double& uptime,
+                     double& idleProcessTime);
+long getTicksPerSec();
+char controlCharsToSpace(char c);
+std::string trimStringRight(std::string_view s);
+
+} // namespace metric_blob
+
+#endif
\ No newline at end of file