workflows: update build and packaging to fix

.github/workflows/build.yaml

@@ -74,6 +74,29 @@ jobs:
         shell: bash
         working-directory: cprofiles/build
 
+  build-debian:
+    name: Debian Buster build to confirm no issues once used downstream
+    runs-on: ubuntu-latest
+    container: debian:buster
+    steps:
+      - name: Set up base image dependencies
+        run: |
+          apt-get update
+          apt-get install -y build-essential cmake make git
+        shell: bash
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Run compilation
+        run: |
+          cmake -DCPROF_TESTS=On ../
+          cmake --build .
+          CTEST_OUTPUT_ON_FAILURE=1 ctest
+        shell: bash
+        working-directory: build
+
   build-unix-arm64:
     name: Build sources on arm64 for ${{ matrix.os }} - ${{ matrix.compiler }}
     runs-on: ${{ matrix.os }}
@@ -161,3 +184,29 @@ jobs:
           # dependencies_debian: ''
           cmakeflags: '-DCPROF_TESTS=On -DCPROF_DEV=on .'
           build_command: make all
+
+  # this job provides the single required status for PRs to be merged into main.
+  # instead of updating the protected branch status in github, developers can update the needs section below
+  # to require additional status checks to protect main.
+  # the job uses the alls-green action to get around the github issue that treats a "skipped" required status check
+  # as passed. github will skip a job if an upstream needed job fails, which would defeat the purpose of this required
+  # status check.
+  test-required-checks-complete:
+    # note: this step always has to run in order to check if the dependent jobs passed. by default github skips running a job
+    # if the needed jobs upstream failed.
+    if: always()
+    needs:
+      - build-windows
+      - build-centos
+      - build-debian
+      - build-unix-arm64
+      - build-unix-amd64
+      - build-analysis-tests
+    name: Required checks complete
+    runs-on: ubuntu-latest
+    permissions: {}
+    steps:
+    - name: Decide whether the needed jobs succeeded or failed
+      uses: re-actors/alls-green@release/v1
+      with:
+        jobs: ${{ toJSON(needs) }}

.github/workflows/lint.yaml

@@ -11,6 +11,8 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: ludeeus/action-shellcheck@master
+        with:
+          ignore_paths: cmake/**
 
   actionlint-pr:
     runs-on: ubuntu-latest

.github/workflows/packages.yaml

@@ -0,0 +1,135 @@
+name: Build packages for master or a tagged release
+
+on:
+  push:
+    branches:
+      - master
+    # Any tag starting with 'v'
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build-distro-packages-arm64:
+    runs-on: ubuntu-latest
+    name: build arm64 packages
+    strategy:
+      fail-fast: false
+      matrix:
+        format: [ rpm, deb ]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+            submodules: true
+
+      - uses: uraimo/[email protected]
+        name: Build the ${{matrix.format}} packages
+        with:
+          arch: aarch64
+          distro: ubuntu_latest
+          run: |
+            apt-get update && \
+            apt-get install -y --no-install-recommends \
+            build-essential \
+            cmake \
+            file \
+            rpm \
+            make
+            cmake .
+            echo ${{ matrix.format }} | awk '{print toupper($0)}' | xargs -I{} cpack -G {}
+
+      - name: Store the master package artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.format }}-arm64
+          path: |
+            ./*.${{matrix.format}}
+
+  build-distro-packages-amd64:
+    name: build amd64 packages
+    strategy:
+      fail-fast: false
+      matrix:
+        format: [ rpm, deb ]
+    runs-on: [ ubuntu-latest ]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+            submodules: true
+
+      - name: Build the ${{matrix.format}} packages
+        run:  |
+          cmake .
+          echo ${{ matrix.format }} | awk '{print toupper($0)}' | xargs -I{} cpack -G {}
+
+      - name: Store the master package artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.format }}-amd64
+          path: |
+            ./*.${{matrix.format}}
+
+  build-macos-packages-arm64:
+    name: build macOS Apple Silicon packages
+    strategy:
+      fail-fast: true
+      matrix:
+        config:
+          - format: productbuild
+            arch: apple
+            ext: pkg
+    runs-on: macos-14
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Build the ${{matrix.config.format}} packages
+        run:  |
+          cmake . -DCPACK_GENERATOR=${{ matrix.config.format }}
+          echo ${{ matrix.config.format }} | xargs -I{} cpack -G {}
+
+      - name: Store the master package artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.config.format }}-${{matrix.config.arch}}
+          path: |
+            ./*-${{matrix.config.arch}}.${{matrix.config.ext}}
+
+  release:
+    name: Create release and upload packages
+    needs:
+      - build-distro-packages-amd64
+      - build-distro-packages-arm64
+      - build-macos-packages-arm64
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download all artefacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts/
+
+      - name: Display structure of downloaded files
+        run: ls -R
+        working-directory: artifacts
+        shell: bash
+
+      - name: Unstable release on push to master to make it easier to download
+        uses: pyTooling/Actions/releaser@r0
+        continue-on-error: true
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: 'unstable'
+          rm: true
+          files: |
+            artifacts/**/*
+
+      - name: Release on tag
+        uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          generate_release_notes: true
+          files: |
+            artifacts/**/*

.mdlrc

@@ -0,0 +1 @@
+style "#{File.dirname(__FILE__)}/markdownlint.rb"

CODEOWNERS

@@ -0,0 +1,7 @@
+# Global Owners
+# -------------
+*                        @edsiper @leonardo-albertovich
+
+# CI
+# -------------------------
+/.github/                @niedbalski @patrick-stephens @celalettin1286

README.md

@@ -2,7 +2,7 @@
 
 The [CProfiles](https://github.com/fluent/cprofiles) provides a simple API to create and manage profiles for monitoring and observability purposes, the internal data structure is based on OpenTelemetry Profiles schema (v1/development):
 
-- https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/profiles/v1development/profiles.proto
+- <https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/profiles/v1development/profiles.proto>
 
 ## Build
 
@@ -33,7 +33,7 @@ make
 
 For now you can try out the unit test that compiles when dev mode is enabled: `tests/cprof-test-profile`:
 
-```
+```text
 --- profile debug
 Profile Duration: 0 nanoseconds
 

cmake/sanitizers-cmake/README.md

@@ -1,48 +1,49 @@
 # sanitizers-cmake
 
- [![](https://img.shields.io/github/issues-raw/arsenm/sanitizers-cmake.svg?style=flat-square)](https://github.com/arsenm/sanitizers-cmake/issues)
+ [![Issues](https://img.shields.io/github/issues-raw/arsenm/sanitizers-cmake.svg?style=flat-square)](https://github.com/arsenm/sanitizers-cmake/issues)
 [![MIT](http://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
 
 CMake module to enable sanitizers for binary targets.
 
-
 ## Include into your project
 
 To use [FindSanitizers.cmake](cmake/FindSanitizers.cmake), simply add this repository as git submodule into your own repository
-```Shell
+
+```shell
 mkdir externals
 git submodule add [email protected]:arsenm/sanitizers-cmake.git externals/sanitizers-cmake
 ```
+
 and adding ```externals/sanitizers-cmake/cmake``` to your ```CMAKE_MODULE_PATH```
+
 ```CMake
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/externals/sanitizers-cmake/cmake" ${CMAKE_MODULE_PATH})
 ```
 
 If you don't use git or dislike submodules you can copy the files in [cmake directory](cmake) into your repository. *Be careful and keep updates in mind!*
 
 Now you can simply run ```find_package``` in your CMake files:
+
 ```CMake
 find_package(Sanitizers)
 ```
 
-
 ## Usage
 
 You can enable the sanitizers with ``SANITIZE_ADDRESS``, ``SANITIZE_MEMORY``, ``SANITIZE_THREAD`` or ``SANITIZE_UNDEFINED`` options in your CMake configuration. You can do this by passing e.g. ``-DSANITIZE_ADDRESS=On`` on your command line or with your graphical interface.
 
 If sanitizers are supported by your compiler, the specified targets will be build with sanitizer support. If your compiler has no sanitizing capabilities (I asume intel compiler doesn't) you'll get a warning but CMake will continue processing and sanitizing will simply just be ignored.
 
-#### Compiler issues
+## Compiler issues
 
 Different compilers may be using different implementations for sanitizers. If you'll try to sanitize targets with C and Fortran code but don't use gcc & gfortran but clang & gfortran, this will cause linking problems. To avoid this, such problems will be detected and sanitizing will be disabled for these targets.
 
 Even C only targets may cause problems in certain situations. Some problems have been seen with AddressSanitizer for preloading or dynamic linking. In such cases you may try the ``SANITIZE_LINK_STATIC`` to link sanitizers for gcc static.
 
-
-
 ## Build targets with sanitizer support
 
 To enable sanitizer support you simply have to add ``add_sanitizers(<TARGET>)`` after defining your target. To provide a sanitizer blacklist file you can use the ``sanitizer_add_blacklist_file(<FILE>)`` function:
+
 ```CMake
 find_package(Sanitizers)
 
@@ -59,15 +60,13 @@ add_sanitizers(some_lib)
 
 The sanitizers check your program, while it's running. In some situations (e.g. LD_PRELOAD your target) it might be required to preload the used AddressSanitizer library first. In this case you may use the ``asan-wrapper`` script defined in ``ASan_WRAPPER`` variable to execute your application with ``${ASan_WRAPPER} myexe arg1 ...``.
 
-
 ## Contribute
 
 Anyone is welcome to contribute. Simply fork this repository, make your changes **in an own branch** and create a pull-request for your change. Please do only one change per pull-request.
 
 You found a bug? Please fill out an [issue](https://github.com/arsenm/sanitizers-cmake/issues) and include any data to reproduce the bug.
 
-
-#### Contributors
+## Contributors
 
 * [Matt Arsenault](https://github.com/arsenm)
 * [Alexander Haase](https://github.com/alehaa)

markdownlint.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby
+
+# Enable all rules by default
+all
+
+# Extend line length, since each sentence should be on a separate line.
+rule 'MD013', :line_length => 99999, :ignore_code_blocks => true
+
+# Allow in-line HTML
+exclude_rule 'MD033'
+
+# Nested lists should be indented with two spaces.
+rule 'MD007', :indent => 2
+
+# Bash defaulting confuses this and now way to ignore code blocks
+exclude_rule 'MD029'