diff --git a/.flake8 b/.flake8
deleted file mode 100644
index af25e839..00000000
--- a/.flake8
+++ /dev/null
@@ -1,10 +0,0 @@
-[flake8]
-max-line-length = 120
-import-order-style = google
-inline-quotes = "
-exclude =
-    ./tests/allure_behave/acceptance/**/test-data/**
-    ./tests/allure_behave/acceptance/behave_support/background/background_steps.py
-per-file-ignores =
-    ./allure-python-commons/src/allure_commons/types.py:A005
-    ./allure-robotframework/src/listener/types.py:A005
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 8178c9b6..7d0b97ea 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,7 +1,7 @@
 <!---
-Thank you so much for sending us a pull request! 
+Thank you so much for sending us a pull request!
 
-Make sure you have a clear name for your pull request. 
+Make sure you have a clear name for your pull request.
 The name should start with a capital letter and no dot is required in the end of the sentence.
 To link the request with issues use the following notation: (fixes #123, fixes #321\)
 
@@ -20,4 +20,4 @@ Describe the problem or feature in addition to a link to the issues
 - [ ] [Sign Allure CLA][cla]
 - [ ] Provide unit tests
 
-[cla]: https://cla-assistant.io/accept/allure-framework/allure2
+[cla]: https://cla-assistant.io/accept/allure-framework/allure-python
diff --git a/.github/release-drafter.yml b/.github/release-drafter.yml
index a9f5bc97..b61eda4e 100644
--- a/.github/release-drafter.yml
+++ b/.github/release-drafter.yml
@@ -1,12 +1,18 @@
-name-template: '$NEXT_MINOR_VERSION'
-tag-template: '$NEXT_MINOR_VERSION'
+name-template: '$RESOLVED_VERSION'
+tag-template: '$RESOLVED_VERSION'
 categories:
   - title: '🚀 New Features'
-    label: 'type:new feature'
+    semver-increment: minor
+    when:
+      label: 'type:new feature'
+
   - title: '🔬 Improvements'
-    label: 'type:improvement'
+    when:
+      label: 'type:improvement'
+
   - title: '🐞 Bug Fixes'
-    label: 'type:bug'
+    when:
+      label: 'type:bug'
 
 change-template: '* $TITLE (via #$NUMBER) - @$AUTHOR'
 template: |
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index 637be25f..b161ef76 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -1,9 +1,16 @@
-name: build allure python
+name: Test Allure Python integrations
 
 on:
   pull_request:
     branches:
-      - master
+      - '*'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   pytest-changes:
@@ -12,7 +19,7 @@ jobs:
     outputs:
       changed: ${{ steps.filter.outputs.allure-pytest }}
     steps:
-      - uses: dorny/paths-filter@v3
+      - uses: dorny/paths-filter@v4
         id: filter
         with:
           filters: |
@@ -29,7 +36,7 @@ jobs:
     outputs:
       packages: ${{ steps.filter.outputs.changes }}
     steps:
-      - uses: dorny/paths-filter@v3
+      - uses: dorny/paths-filter@v4
         id: filter
         with:
           filters: |
@@ -74,18 +81,18 @@ jobs:
     needs: [pytest-changes, other-changes]
     if: ${{ needs.pytest-changes.outputs.changed == 'true' || needs.other-changes.outputs.packages != '[]' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
-          python-version: "3.13"
+          python-version: "3.14"
 
       - name: Install linting packages
         run: pip install -r ./requirements/linting.txt
 
       - name: Linting the codebase
-        run: poe linter
+        run: poe linter --output-format=github
 
   test-pytest:
     name: Test allure-pytest
@@ -94,16 +101,15 @@ jobs:
     if: ${{ needs.pytest-changes.outputs.changed == 'true' }}
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
-        pytest-version: ["7.*", "8.*"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        pytest-version: ["7.*", "8.*", "9.*"]
     env:
-      TEST_TMP: /tmp
       ALLURE_INDENT_OUTPUT: yep
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -128,17 +134,16 @@ jobs:
     strategy:
       matrix:
         package: ${{ fromJSON(needs.other-changes.outputs.packages) }}
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
         exclude:
           - package: allure-pytest
     env:
-      TEST_TMP: /tmp
       ALLURE_INDENT_OUTPUT: yep
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python-version }}
 
diff --git a/.github/workflows/release-drafter.yml b/.github/workflows/release-drafter.yml
index 2d6b8ccb..66c8a789 100644
--- a/.github/workflows/release-drafter.yml
+++ b/.github/workflows/release-drafter.yml
@@ -5,10 +5,16 @@ on:
     branches:
       - master
 
+permissions:
+  contents: read
+
 jobs:
   update_draft_release:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
-      - uses: toolmantim/release-drafter@v5.2.0
+      - uses: toolmantim/release-drafter@v7
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 10b3295f..fb0c8fa0 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -5,15 +5,18 @@ on:
   release:
     types: [published]
 
+permissions:
+  contents: read
+
 jobs:
   deploy:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v7
 
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v7
       with:
         python-version: '3.x'
 
diff --git a/.github/workflows/test-all.yaml b/.github/workflows/test-all.yaml
new file mode 100644
index 00000000..506d35f9
--- /dev/null
+++ b/.github/workflows/test-all.yaml
@@ -0,0 +1,81 @@
+name: Scheduled testing
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Runs at 05:30 on Mondays
+    - cron: "30 5 * * 1"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test-pytest:
+    name: Test allure-pytest
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        pytest-version: ["7.*", "8.*", "9.*"]
+    env:
+      ALLURE_INDENT_OUTPUT: yep
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install packages
+        run: |
+          pip install ./allure-python-commons \
+            ./allure-python-commons-test \
+            ./allure-pytest \
+            pytest==${{ matrix.pytest-version }} \
+            -r ./requirements/testing.txt \
+            -r ./requirements/testing/allure-pytest.txt
+
+      - name: Test allure-pytest
+        working-directory: allure-pytest
+        run: poe tests
+
+  test-others:
+    name: Test other packages
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        package: [
+            "allure-behave",
+            "allure-nose2",
+            "allure-pytest-bdd",
+            "allure-python-commons",
+            "allure-python-commons-test",
+            "allure-robotframework",
+        ]
+    env:
+      ALLURE_INDENT_OUTPUT: yep
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install packages
+        run: |
+          pip install ./allure-python-commons \
+            ./allure-python-commons-test \
+            ./${{ matrix.package }} \
+            -r ./requirements/testing.txt \
+            -r ./requirements/testing/${{ matrix.package }}.txt
+
+      - name: Test ${{ matrix.package }}
+        working-directory: ${{ matrix.package }}
+        run: poe tests
diff --git a/.gitignore b/.gitignore
index 25e4deb0..7b7033cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@
 .tox
 .pytest_cache
 .python-version
+.ruff_cache
 .venv
 
 *.pyc
diff --git a/Jenkinsfile b/Jenkinsfile
deleted file mode 100644
index 7b6fd0ee..00000000
--- a/Jenkinsfile
+++ /dev/null
@@ -1,17 +0,0 @@
-pipeline {
-    agent { docker 'randomknowledge/docker-pyenv-tox' }
-    environment {
-        HOME = pwd()
-    }
-    stages {
-        stage("Build") {
-            steps {
-                sh 'tox -r --workdir=/tmp -c allure-python-commons-test/tox.ini'
-                sh 'tox -r --workdir=/tmp -c allure-python-commons/tox.ini'
-                sh 'tox -r --workdir=/tmp -c allure-pytest/tox.ini'
-                sh 'tox -r --workdir=/tmp -c allure-behave/tox.ini'
-                sh 'tox -r --workdir=/tmp -c allure-robotframework/tox.ini'
-            }
-        }
-    }
-}
diff --git a/allure-behave/pyproject.toml b/allure-behave/pyproject.toml
index 388f9913..442ac2d8 100644
--- a/allure-behave/pyproject.toml
+++ b/allure-behave/pyproject.toml
@@ -1,5 +1,5 @@
 [tool.poe.tasks]
-linter = "flake8 --extend-ignore=A003 ./src"
+linter = "ruff check"
 
 [tool.poe.tasks.tests]
 cmd = "pytest ../tests/allure_behave"
diff --git a/allure-behave/setup.py b/allure-behave/setup.py
index 9bb3dc41..2fd05e97 100644
--- a/allure-behave/setup.py
+++ b/allure-behave/setup.py
@@ -4,24 +4,24 @@
 PACKAGE = "allure-behave"
 
 classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: Apache Software License',
-    'Topic :: Software Development :: Quality Assurance',
-    'Topic :: Software Development :: Testing',
-    'Topic :: Software Development :: Testing :: BDD',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'Programming Language :: Python :: 3.13',
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Testing :: BDD",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 setup_requires = [
-    "setuptools_scm"
+    "setuptools_scm<10"
 ]
 
 install_requires = [
@@ -64,5 +64,5 @@ def main():
         install_requires=install_requires
     )
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/allure-behave/src/formatter.py b/allure-behave/src/formatter.py
index febd2d96..fd5576f1 100644
--- a/allure-behave/src/formatter.py
+++ b/allure-behave/src/formatter.py
@@ -24,7 +24,7 @@ def _wrap_scenario(self, scenarios):
             if isinstance(scenario, ScenarioOutline):
                 self._wrap_scenario(scenario)
             else:
-                scenario.run = allure_commons.test(scenario.run, context={'scenario': scenario})
+                scenario.run = allure_commons.test(scenario.run, context={"scenario": scenario})
             is_planned_scenario(scenario, self.testplan)
 
     def uri(self, uri):
diff --git a/allure-behave/src/hooks.py b/allure-behave/src/hooks.py
index 7a153020..0873d94a 100644
--- a/allure-behave/src/hooks.py
+++ b/allure-behave/src/hooks.py
@@ -45,7 +45,7 @@ def __init__(self, result_dir):
         self.listener = AllureListener(Configuration())
         self.plugins = []
 
-        if not hasattr(_storage, 'file_logger'):
+        if not hasattr(_storage, "file_logger"):
             logger = AllureFileLogger(result_dir)
             _storage.file_logger = logger
             allure_commons.plugin_manager.register(logger)
diff --git a/allure-behave/src/listener.py b/allure-behave/src/listener.py
index b9a86d55..a39d0e91 100644
--- a/allure-behave/src/listener.py
+++ b/allure-behave/src/listener.py
@@ -2,6 +2,7 @@
 import allure_commons
 from allure_commons.reporter import AllureReporter
 from allure_commons.utils import uuid4
+from allure_commons.utils import md5
 from allure_commons.utils import now
 from allure_commons.utils import platform_label
 from allure_commons.types import LabelType, AttachmentType, LinkType
@@ -20,6 +21,7 @@
 from allure_behave.utils import scenario_links
 from allure_behave.utils import scenario_labels
 from allure_behave.utils import get_fullname
+from allure_behave.utils import get_title_path
 from allure_behave.utils import TEST_PLAN_SKIP_REASON
 from allure_behave.utils import get_hook_name
 
@@ -27,9 +29,9 @@
 class AllureListener:
     def __init__(self, behave_config):
         self.behave_config = behave_config
-        self.issue_pattern = behave_config.userdata.get('AllureFormatter.issue_pattern', None)
-        self.link_pattern = behave_config.userdata.get('AllureFormatter.link_pattern', None)
-        self.hide_excluded = behave_config.userdata.get('AllureFormatter.hide_excluded', False)
+        self.issue_pattern = behave_config.userdata.get("AllureFormatter.issue_pattern", None)
+        self.link_pattern = behave_config.userdata.get("AllureFormatter.link_pattern", None)
+        self.hide_excluded = behave_config.userdata.get("AllureFormatter.hide_excluded", False)
         self.logger = AllureReporter()
         self.current_step_uuid = None
         self.current_scenario_uuid = None
@@ -68,7 +70,7 @@ def stop_feature(self):
 
     @allure_commons.hookimpl
     def start_test(self, parent_uuid, uuid, name, parameters, context):
-        self.start_scenario(context['scenario'])
+        self.start_scenario(context["scenario"])
 
     def start_scenario(self, scenario):
         self.current_scenario_uuid = uuid4()
@@ -77,8 +79,10 @@ def start_scenario(self, scenario):
         test_case = TestResult(uuid=self.current_scenario_uuid, start=now())
         test_case.name = scenario_name(scenario)
         test_case.fullName = get_fullname(scenario)
+        test_case.titlePath = get_title_path(scenario)
         test_case.historyId = scenario_history_id(scenario)
-        test_case.description = '\n'.join(scenario.description)
+        test_case.testCaseId = md5(test_case.fullName)
+        test_case.description = "\n".join(scenario.description)
         test_case.parameters = scenario_parameters(scenario)
 
         test_case.links.extend(scenario_links(
@@ -87,20 +91,20 @@ def start_scenario(self, scenario):
             link_pattern=self.link_pattern))
         test_case.labels.extend(scenario_labels(scenario))
         test_case.labels.append(Label(name=LabelType.FEATURE, value=scenario.feature.name))
-        test_case.labels.append(Label(name=LabelType.FRAMEWORK, value='behave'))
+        test_case.labels.append(Label(name=LabelType.FRAMEWORK, value="behave"))
         test_case.labels.append(Label(name=LabelType.LANGUAGE, value=platform_label()))
 
         self.logger.schedule_test(self.current_scenario_uuid, test_case)
 
     @allure_commons.hookimpl
     def stop_test(self, parent_uuid, uuid, name, context, exc_type, exc_val, exc_tb):
-        self.stop_scenario(context['scenario'])
+        self.stop_scenario(context["scenario"])
 
     def stop_scenario(self, scenario):
         tag_expression = self.__get_tag_expression(self.behave_config)
         should_run = scenario.should_run_with_tags(tag_expression)
         should_run = should_run and scenario.should_run_with_name_select(self.behave_config)
-        should_drop_skipped_by_option = scenario.status == 'skipped' and not self.behave_config.show_skipped
+        should_drop_skipped_by_option = scenario.status == "skipped" and not self.behave_config.show_skipped
         should_drop_excluded = self.hide_excluded and (scenario.skip_reason == TEST_PLAN_SKIP_REASON or not should_run)
 
         if should_drop_skipped_by_option or should_drop_excluded:
@@ -131,16 +135,16 @@ def match_step(self, match):
     def start_behave_step(self, step):
 
         self.current_step_uuid = uuid4()
-        name = f'{step.keyword} {step.name}'
+        name = f"{step.keyword} {step.name}"
 
         allure_step = TestStepResult(name=name, start=now())
         self.logger.start_step(None, self.current_step_uuid, allure_step)
 
         if step.text:
-            self.logger.attach_data(uuid4(), step.text, name='.text', attachment_type=AttachmentType.TEXT)
+            self.logger.attach_data(uuid4(), step.text, name=".text", attachment_type=AttachmentType.TEXT)
 
         if step.table:
-            self.logger.attach_data(uuid4(), step_table(step), name='.table', attachment_type=AttachmentType.CSV)
+            self.logger.attach_data(uuid4(), step_table(step), name=".table", attachment_type=AttachmentType.CSV)
 
     def stop_behave_step(self, result):
         status = step_status(result)
@@ -174,6 +178,18 @@ def attach_data(self, body, name, attachment_type, extension):
     def attach_file(self, source, name, attachment_type, extension):
         self.logger.attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)
 
+    @allure_commons.hookimpl
+    def global_attach_data(self, body, name, attachment_type, extension):
+        self.logger.global_attach_data(uuid4(), body, name=name, attachment_type=attachment_type, extension=extension)
+
+    @allure_commons.hookimpl
+    def global_attach_file(self, source, name, attachment_type, extension):
+        self.logger.global_attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)
+
+    @allure_commons.hookimpl
+    def global_error(self, message, trace, status):
+        self.logger.global_error(message=message, trace=trace, status=status)
+
     @allure_commons.hookimpl
     def add_description(self, test_description):
         test_result = self.logger.get_test(None)
@@ -190,7 +206,7 @@ def add_description_html(self, test_description_html):
     def add_link(self, url, link_type, name):
         test_result = self.logger.get_test(None)
         if test_result:
-            pattern = '{}'
+            pattern = "{}"
             if link_type == LinkType.ISSUE and self.issue_pattern:
                 pattern = self.issue_pattern
             elif link_type == LinkType.LINK and self.link_pattern:
@@ -226,7 +242,7 @@ def enter(self):
         self._logger.start_group(group.uuid, group)
         self._groups.append(group)
 
-    def exit(self):  # noqa: A003
+    def exit(self):
         group = self._groups.pop()
         if group.befores or group.afters:
             self._logger.stop_group(group.uuid)
diff --git a/allure-behave/src/utils.py b/allure-behave/src/utils.py
index b77fe6c4..da5cf073 100644
--- a/allure-behave/src/utils.py
+++ b/allure-behave/src/utils.py
@@ -1,6 +1,7 @@
 import csv
 import io
 from enum import Enum
+from pathlib import Path
 from behave.runner_util import make_undefined_step_snippet
 from allure_commons.types import Severity, LabelType
 from allure_commons.model2 import Status, Parameter
@@ -13,11 +14,11 @@
 TEST_PLAN_SKIP_REASON = "Not in allure test plan"
 
 STATUS = {
-    'passed': Status.PASSED,
-    'failed': Status.FAILED,
-    'skipped': Status.SKIPPED,
-    'untested': Status.SKIPPED,
-    'undefined': Status.BROKEN
+    "passed": Status.PASSED,
+    "failed": Status.FAILED,
+    "skipped": Status.SKIPPED,
+    "untested": Status.SKIPPED,
+    "undefined": Status.BROKEN
 }
 
 
@@ -29,7 +30,7 @@ def scenario_history_id(scenario):
     parts = [scenario.feature.name, scenario.name]
     if scenario._row:
         row = scenario._row
-        parts.extend([f'{name}={value}' for name, value in zip(row.headings, row.cells)])
+        parts.extend([f"{name}={value}" for name, value in zip(row.headings, row.cells)])
     return md5(*parts)
 
 
@@ -56,14 +57,14 @@ def scenario_labels(scenario):
 
 def scenario_status(scenario):
     for step in scenario.all_steps:
-        if step_status(step) != 'passed':
+        if step_status(step) != "passed":
             return step_status(step)
     return Status.PASSED
 
 
 def scenario_status_details(scenario):
     for step in scenario.all_steps:
-        if step_status(step) != 'passed':
+        if step_status(step) != "passed":
             return step_status_details(step)
 
 
@@ -97,6 +98,29 @@ def get_fullname(scenario):
     return f"{scenario.feature.name}: {name}"
 
 
+def get_title_path(scenario):
+    path_parts = []
+    feature_part = scenario.feature.name
+
+    # filename is set to "<string>" if the feature comes from a string literal
+    if scenario.filename and scenario.filename != "<string>":
+        path = Path(scenario.filename)
+
+        # remove the filename because it's redundant: a feature file can only have one feature defined
+        path_parts = path.parts[:-1]
+
+        if not feature_part:
+            # if no feature name is defined, fallback to the filename
+            feature_part = path.name
+
+    if not feature_part:
+        # Neither feature name nor filename is defined, use the "Feature" keyword
+        feature_part = scenario.feature.keyword
+
+    # reminder: scenario name should not be included in titlePath because it is already part of the test case title
+    return [*path_parts, feature_part]
+
+
 def get_hook_name(name, parameters):
     tag = None
     if name in ["before_tag", "after_tag"]:
@@ -127,8 +151,8 @@ def step_status_details(result):
             trace=trace
         )
 
-    elif result.status == 'undefined':
-        message = '\nYou can implement step definitions for undefined steps with these snippets:\n\n'
+    elif result.status == "undefined":
+        message = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
         message += make_undefined_step_snippet(result)
         return StatusDetails(message=message)
 
diff --git a/allure-nose2/pyproject.toml b/allure-nose2/pyproject.toml
index 822f5d98..a411cd33 100644
--- a/allure-nose2/pyproject.toml
+++ b/allure-nose2/pyproject.toml
@@ -1,5 +1,5 @@
 [tool.poe.tasks]
-linter = "flake8 ./src"
+linter = "ruff check"
 
 [tool.poe.tasks.tests]
 cmd = "pytest ../tests/allure_nose2"
diff --git a/allure-nose2/setup.py b/allure-nose2/setup.py
index 6f7a1ec5..11c4babc 100644
--- a/allure-nose2/setup.py
+++ b/allure-nose2/setup.py
@@ -4,23 +4,23 @@
 PACKAGE = "allure-nose2"
 
 classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: Apache Software License',
-    'Topic :: Software Development :: Quality Assurance',
-    'Topic :: Software Development :: Testing',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'Programming Language :: Python :: 3.13',
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 setup_requires = [
-    "setuptools_scm"
+    "setuptools_scm<10"
 ]
 
 install_requires = [
@@ -63,5 +63,5 @@ def main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/allure-nose2/src/plugin.py b/allure-nose2/src/plugin.py
index c7f64608..edd4d65d 100644
--- a/allure-nose2/src/plugin.py
+++ b/allure-nose2/src/plugin.py
@@ -14,6 +14,7 @@
 
 
 from .utils import timestamp_millis, status_details, update_attrs, labels, name, fullname, params
+from .utils import get_title_path
 import allure_commons
 
 
@@ -43,7 +44,7 @@ def unregister(cls):
 
 
 class Allure(Plugin):
-    configSection = 'allure'
+    configSection = "allure"
     commandLineSwitch = (None, "allure", "Generate an Allure report")
 
     def __init__(self, *args, **kwargs):
@@ -90,10 +91,11 @@ def startTest(self, event):
                 test_result.fullName = fullname(event)
                 test_result.testCaseId = md5(test_result.fullName)
                 test_result.historyId = md5(event.test.id())
+                test_result.titlePath = get_title_path(event)
                 test_result.labels.extend(labels(event.test))
                 test_result.labels.append(Label(name=LabelType.HOST, value=self._host))
                 test_result.labels.append(Label(name=LabelType.THREAD, value=self._thread))
-                test_result.labels.append(Label(name=LabelType.FRAMEWORK, value='nose2'))
+                test_result.labels.append(Label(name=LabelType.FRAMEWORK, value="nose2"))
                 test_result.labels.append(Label(name=LabelType.LANGUAGE, value=platform_label()))
                 test_result.parameters = params(event)
 
diff --git a/allure-nose2/src/utils.py b/allure-nose2/src/utils.py
index 691e75c7..23e83d23 100644
--- a/allure-nose2/src/utils.py
+++ b/allure-nose2/src/utils.py
@@ -7,9 +7,9 @@
 
 # ToDo move to commons
 ALLURE_LABELS = [
-    'epic',
-    'feature',
-    'story',
+    "epic",
+    "feature",
+    "story",
 ]
 
 
@@ -21,8 +21,8 @@ def status_details(event):
     message, trace = None, None
     if event.exc_info:
         exc_type, value, _ = event.exc_info
-        message = '\n'.join(format_exception_only(exc_type, value)) if exc_type or value else None
-        trace = ''.join(util.exc_info_to_string(event.exc_info, event.test))
+        message = "\n".join(format_exception_only(exc_type, value)) if exc_type or value else None
+        trace = "".join(util.exc_info_to_string(event.exc_info, event.test))
     elif event.reason:
         message = event.reason
 
@@ -81,6 +81,11 @@ def fullname(event):
     return test_id.split(":")[0]
 
 
+def get_title_path(event):
+    test_id = event.test.id()
+    return test_id.split(":", 1)[0].rsplit(".")[:-1]
+
+
 def params(event):
     def _params(names, values):
         return [Parameter(name=name, value=represent(value)) for name, value in zip(names, values)]
diff --git a/allure-pytest-bdd/pyproject.toml b/allure-pytest-bdd/pyproject.toml
index 83277cf5..ec703429 100644
--- a/allure-pytest-bdd/pyproject.toml
+++ b/allure-pytest-bdd/pyproject.toml
@@ -1,5 +1,5 @@
 [tool.poe.tasks]
-linter = "flake8 ./src"
+linter = "ruff check"
 
 [tool.poe.tasks.tests]
 cmd = "pytest ../tests/allure_pytest_bdd"
diff --git a/allure-pytest-bdd/setup.py b/allure-pytest-bdd/setup.py
index 4e651458..6f7553d2 100644
--- a/allure-pytest-bdd/setup.py
+++ b/allure-pytest-bdd/setup.py
@@ -4,25 +4,25 @@
 PACKAGE = "allure-pytest-bdd"
 
 classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Framework :: Pytest',
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: Apache Software License',
-    'Topic :: Software Development :: Quality Assurance',
-    'Topic :: Software Development :: Testing',
-    'Topic :: Software Development :: Testing :: BDD',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'Programming Language :: Python :: 3.13',
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Testing :: BDD",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 setup_requires = [
-    "setuptools_scm"
+    "setuptools_scm<10"
 ]
 
 install_requires = [
@@ -67,5 +67,5 @@ def main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/allure-pytest-bdd/src/allure_api_listener.py b/allure-pytest-bdd/src/allure_api_listener.py
index e132e8e2..0043a5c2 100644
--- a/allure-pytest-bdd/src/allure_api_listener.py
+++ b/allure-pytest-bdd/src/allure_api_listener.py
@@ -16,6 +16,9 @@
 from .utils import apply_link_pattern
 from .utils import attach_data
 from .utils import attach_file
+from .utils import global_attach_data
+from .utils import global_attach_file
+from .utils import global_error
 from .utils import get_link_patterns
 from .steps import start_step
 from .steps import stop_step
@@ -117,3 +120,15 @@ def attach_data(self, body, name, attachment_type, extension):
     @allure_commons.hookimpl
     def attach_file(self, source, name, attachment_type, extension):
         attach_file(self.lifecycle, source, name, attachment_type, extension)
+
+    @allure_commons.hookimpl
+    def global_attach_data(self, body, name, attachment_type, extension):
+        global_attach_data(self.lifecycle, body, name, attachment_type, extension)
+
+    @allure_commons.hookimpl
+    def global_attach_file(self, source, name, attachment_type, extension):
+        global_attach_file(self.lifecycle, source, name, attachment_type, extension)
+
+    @allure_commons.hookimpl
+    def global_error(self, message, trace, status):
+        global_error(self.lifecycle, message, trace, status)
diff --git a/allure-pytest-bdd/src/plugin.py b/allure-pytest-bdd/src/plugin.py
index 521eadc4..0579c66e 100644
--- a/allure-pytest-bdd/src/plugin.py
+++ b/allure-pytest-bdd/src/plugin.py
@@ -15,20 +15,20 @@
 
 
 def pytest_addoption(parser):
-    parser.getgroup("reporting").addoption('--alluredir',
+    parser.getgroup("reporting").addoption("--alluredir",
                                            action="store",
                                            dest="allure_report_dir",
                                            metavar="DIR",
                                            default=None,
                                            help="Generate Allure report in the specified directory (may not exist)")
 
-    parser.getgroup("reporting").addoption('--clean-alluredir',
+    parser.getgroup("reporting").addoption("--clean-alluredir",
                                            action="store_true",
                                            dest="clean_alluredir",
                                            help="Clean alluredir folder if it exists")
 
     def link_pattern(string):
-        pattern = string.split(':', 1)
+        pattern = string.split(":", 1)
         if not pattern[0]:
             raise argparse.ArgumentTypeError("A link type is mandatory")
 
diff --git a/allure-pytest-bdd/src/pytest_bdd_listener.py b/allure-pytest-bdd/src/pytest_bdd_listener.py
index d0697380..5a96731d 100644
--- a/allure-pytest-bdd/src/pytest_bdd_listener.py
+++ b/allure-pytest-bdd/src/pytest_bdd_listener.py
@@ -1,5 +1,7 @@
 import pytest
 
+from collections import defaultdict
+
 from allure_commons.utils import now
 from allure_commons.model2 import Label
 from allure_commons.model2 import Status
@@ -7,6 +9,7 @@
 from allure_commons.utils import platform_label
 from allure_commons.utils import host_tag, thread_tag
 from allure_commons.utils import md5
+from allure_commons.utils import uuid4
 
 from .steps import get_step_uuid
 from .steps import process_gherkin_step_args
@@ -23,12 +26,12 @@
 from .utils import get_allure_links
 from .utils import convert_params
 from .utils import get_full_name
+from .utils import get_title_path
 from .utils import get_outline_params
 from .utils import get_pytest_params
 from .utils import get_pytest_report_status
 from .utils import get_scenario_status_details
 from .utils import get_test_name
-from .utils import get_uuid
 from .utils import post_process_test_result
 
 from functools import partial
@@ -39,11 +42,12 @@ def __init__(self, lifecycle):
         self.lifecycle = lifecycle
         self.host = host_tag()
         self.thread = thread_tag()
+        self.nodeid_to_uuid = defaultdict(uuid4)
 
     @pytest.hookimpl
     def pytest_bdd_before_scenario(self, request, feature, scenario):
         item = request.node
-        uuid = get_uuid(item.nodeid)
+        uuid = self.nodeid_to_uuid[item.nodeid]
 
         outline_params = get_outline_params(item)
         pytest_params = get_pytest_params(item)
@@ -59,6 +63,7 @@ def pytest_bdd_before_scenario(self, request, feature, scenario):
         full_name = get_full_name(feature, scenario)
         with self.lifecycle.schedule_test_case(uuid=uuid) as test_result:
             test_result.fullName = full_name
+            test_result.titlePath = get_title_path(request, feature)
             test_result.name = get_test_name(item, scenario, params)
             test_result.description = get_allure_description(item, feature, scenario)
             test_result.descriptionHtml = get_allure_description_html(item)
@@ -72,18 +77,19 @@ def pytest_bdd_before_scenario(self, request, feature, scenario):
             test_result.links.extend(get_allure_links(item))
             test_result.parameters.extend(convert_params(outline_params, pytest_params))
 
-        finalizer = partial(report_remaining_steps, self.lifecycle, item)
+        finalizer = partial(report_remaining_steps, self.lifecycle, item, uuid)
         item.addfinalizer(finalizer)
 
     @pytest.hookimpl
     def pytest_bdd_after_scenario(self, request, feature, scenario):
-        uuid = get_uuid(request.node.nodeid)
+        uuid = self.nodeid_to_uuid[request.node.nodeid]
         with self.lifecycle.update_test_case(uuid=uuid) as test_result:
             test_result.stop = now()
 
     @pytest.hookimpl
     def pytest_bdd_before_step(self, request, feature, scenario, step, step_func):
-        start_gherkin_step(self.lifecycle, request.node, step, step_func)
+        uuid = self.nodeid_to_uuid[request.node.nodeid]
+        start_gherkin_step(self.lifecycle, request.node, uuid, step, step_func)
 
     @pytest.hookimpl
     def pytest_bdd_before_step_call(self, request, feature, scenario, step, step_func, step_func_args):
@@ -99,7 +105,8 @@ def pytest_bdd_step_error(self, request, feature, scenario, step, step_func, ste
 
     @pytest.hookimpl
     def pytest_bdd_step_func_lookup_error(self, request, feature, scenario, step, exception):
-        report_undefined_step(self.lifecycle, request.node, step, exception)
+        uuid = self.nodeid_to_uuid[request.node.nodeid]
+        report_undefined_step(self.lifecycle, request.node, uuid, step, exception)
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_makereport(self, item, call):
@@ -110,7 +117,8 @@ def pytest_runtest_makereport(self, item, call):
         status = get_pytest_report_status(report, excinfo)
         status_details = get_scenario_status_details(report, excinfo)
 
-        uuid = get_uuid(report.nodeid)
+        uuid = self.nodeid_to_uuid[report.nodeid]
+
         with self.lifecycle.update_test_case(uuid=uuid) as test_result:
 
             if test_result and report.when == "setup":
@@ -139,5 +147,6 @@ def pytest_runtest_makereport(self, item, call):
                     attach_data(self.lifecycle, report.capstderr, "stderr", AttachmentType.TEXT, None)
                 post_process_test_result(item, test_result)
 
-        if report.when == 'teardown':
+        if report.when == "teardown":
             self.lifecycle.write_test_case(uuid=uuid)
+            del self.nodeid_to_uuid[report.nodeid]
diff --git a/allure-pytest-bdd/src/steps.py b/allure-pytest-bdd/src/steps.py
index cfc2741b..0667a88e 100644
--- a/allure-pytest-bdd/src/steps.py
+++ b/allure-pytest-bdd/src/steps.py
@@ -1,9 +1,12 @@
+from uuid import UUID
+
 from allure import attachment_type
 from allure_commons.model2 import StatusDetails
 from allure_commons.model2 import Status
 from allure_commons.model2 import Parameter
 from allure_commons.utils import format_exception
 from allure_commons.utils import represent
+from allure_commons.utils import md5
 
 from .storage import get_saved_params
 from .storage import get_test_data
@@ -11,7 +14,6 @@
 from .utils import attach_data
 from .utils import format_csv
 from .utils import get_allure_title
-from .utils import get_uuid
 from .utils import get_status
 from .utils import get_status_details
 
@@ -32,7 +34,7 @@ def get_allure_title_of_step(item, step_func, step_func_args):
 
 
 def get_step_uuid(step):
-    return get_uuid(str(id(step)))
+    return str(UUID(md5(id(step))))
 
 
 def start_step(lifecycle, step_uuid, title, params=None, parent_uuid=None):
@@ -57,7 +59,7 @@ def stop_step(lifecycle, uuid, status=None, status_details=None, exception=None,
     return True
 
 
-def start_gherkin_step(lifecycle, item, step, step_func=None, step_uuid=None):
+def start_gherkin_step(lifecycle, item, test_uuid, step, step_func=None, step_uuid=None):
     if step_uuid is None:
         step_uuid = get_step_uuid(step)
 
@@ -65,7 +67,7 @@ def start_gherkin_step(lifecycle, item, step, step_func=None, step_uuid=None):
         lifecycle,
         step_uuid=step_uuid,
         title=get_step_name(item, step, step_func),
-        parent_uuid=get_uuid(item.nodeid),
+        parent_uuid=test_uuid,
     )
 
 
@@ -152,7 +154,7 @@ def stop_gherkin_step(lifecycle, item, step_uuid, **kwargs):
     return res
 
 
-def ensure_gherkin_step_reported(lifecycle, item, step, step_uuid=None, **kwargs):
+def ensure_gherkin_step_reported(lifecycle, item, test_uuid, step, step_uuid=None, **kwargs):
 
     if not step_uuid:
         step_uuid = get_step_uuid(step)
@@ -160,14 +162,15 @@ def ensure_gherkin_step_reported(lifecycle, item, step, step_uuid=None, **kwargs
     if stop_gherkin_step(lifecycle, item, step_uuid, **kwargs):
         return
 
-    start_gherkin_step(lifecycle, item, step, step_uuid=step_uuid)
+    start_gherkin_step(lifecycle, item, test_uuid, step, step_uuid=step_uuid)
     stop_gherkin_step(lifecycle, item, step_uuid, **kwargs)
 
 
-def report_undefined_step(lifecycle, item, step, exception):
+def report_undefined_step(lifecycle, item, test_uuid, step, exception):
     ensure_gherkin_step_reported(
         lifecycle,
         item,
+        test_uuid,
         step,
         status=Status.BROKEN,
         status_details=StatusDetails(
@@ -176,7 +179,7 @@ def report_undefined_step(lifecycle, item, step, exception):
     )
 
 
-def report_remaining_steps(lifecycle, item):
+def report_remaining_steps(lifecycle, item, test_uuid):
     test_data = get_test_data(item)
     scenario = test_data.scenario
     excinfo = test_data.excinfo
@@ -185,12 +188,12 @@ def report_remaining_steps(lifecycle, item):
     for step in scenario.steps:
         step_uuid = get_step_uuid(step)
         if step_uuid not in reported_steps:
-            __report_remaining_step(lifecycle, item, step, step_uuid, excinfo)
+            __report_remaining_step(lifecycle, item, test_uuid, step, step_uuid, excinfo)
             excinfo = None  # Only show the full message and traceback once
 
 
-def __report_remaining_step(lifecycle, item, step, step_uuid, excinfo):
-    args = [lifecycle, item, step, step_uuid]
+def __report_remaining_step(lifecycle, item, test_uuid, step, step_uuid, excinfo):
+    args = [lifecycle, item, test_uuid, step, step_uuid]
     kwargs = {
         "exception": excinfo.value,
         "exception_type": excinfo.type,
diff --git a/allure-pytest-bdd/src/utils.py b/allure-pytest-bdd/src/utils.py
index 1ba59aa2..02ed0b86 100644
--- a/allure-pytest-bdd/src/utils.py
+++ b/allure-pytest-bdd/src/utils.py
@@ -2,10 +2,11 @@
 import io
 import os
 from urllib.parse import urlparse
-from uuid import UUID
+from pathlib import Path
 
 import pytest
 
+from allure_commons.types import ErrorStatus
 from allure_commons.model2 import Label
 from allure_commons.model2 import Link
 from allure_commons.model2 import StatusDetails
@@ -26,8 +27,8 @@
 ALLURE_TITLE_ATTR = "__allure_display_name__"
 ALLURE_DESCRIPTION_MARK = "allure_description"
 ALLURE_DESCRIPTION_HTML_MARK = "allure_description_html"
-ALLURE_LABEL_MARK = 'allure_label'
-ALLURE_LINK_MARK = 'allure_link'
+ALLURE_LABEL_MARK = "allure_label"
+ALLURE_LINK_MARK = "allure_link"
 
 MARK_NAMES_TO_IGNORE = {
     "usefixtures",
@@ -171,8 +172,14 @@ def get_full_name(feature, scenario):
     return f"{feature_path}:{scenario.name}"
 
 
-def get_uuid(*args):
-    return str(UUID(md5(*args)))
+def get_rootdir(request):
+    config = request.config
+    return getattr(config, "rootpath", None) or Path(config.rootdir)
+
+
+def get_title_path(request, feature):
+    parts = Path(feature.filename).relative_to(get_rootdir(request)).parts
+    return [*parts[:-1], feature.name or parts[-1]]
 
 
 def get_status(exception):
@@ -225,13 +232,13 @@ def get_scenario_status_details(report, excinfo):
 
 
 def get_outline_params(node):
-    if hasattr(node, 'callspec'):
-        return node.callspec.params.get('_pytest_bdd_example', {})
+    if hasattr(node, "callspec"):
+        return node.callspec.params.get("_pytest_bdd_example", {})
     return {}
 
 
 def get_pytest_params(node):
-    if hasattr(node, 'callspec'):
+    if hasattr(node, "callspec"):
         pytest_params = dict(node.callspec.params)
         if "_pytest_bdd_example" in pytest_params:
             del pytest_params["_pytest_bdd_example"]
@@ -312,6 +319,30 @@ def attach_file(lifecycle, source, name, attachment_type, extension=None):
     )
 
 
+def global_attach_data(lifecycle, body, name, attachment_type, extension=None):
+    lifecycle.global_attach_data(
+        uuid4(),
+        body,
+        name=name,
+        attachment_type=attachment_type,
+        extension=extension,
+    )
+
+
+def global_attach_file(lifecycle, source, name, attachment_type, extension=None):
+    lifecycle.global_attach_file(
+        uuid4(),
+        source,
+        name=name,
+        attachment_type=attachment_type,
+        extension=extension,
+    )
+
+
+def global_error(lifecycle, message, trace=None, status=ErrorStatus.BROKEN):
+    lifecycle.global_error(message=message, trace=trace, status=status)
+
+
 def format_csv(rows):
     with io.StringIO() as buffer:
         writer = csv.writer(buffer)
diff --git a/allure-pytest/pyproject.toml b/allure-pytest/pyproject.toml
index 22458017..98187503 100644
--- a/allure-pytest/pyproject.toml
+++ b/allure-pytest/pyproject.toml
@@ -1,5 +1,5 @@
 [tool.poe.tasks]
-linter = "flake8 ./src"
+linter = "ruff check"
 
 [tool.poe.tasks.tests]
 cmd = "pytest ../tests/allure_pytest"
diff --git a/allure-pytest/setup.py b/allure-pytest/setup.py
index 6597abf5..ce0016bf 100644
--- a/allure-pytest/setup.py
+++ b/allure-pytest/setup.py
@@ -1,39 +1,27 @@
-import os,sys
+import os
 from setuptools import setup
-from pkg_resources import require, DistributionNotFound, VersionConflict
-
-try:
-    require('pytest-allure-adaptor')
-    print("""
-    You have pytest-allure-adaptor installed.
-    You need to remove pytest-allure-adaptor from your site-packages
-    before installing allure-pytest, or conflicts may result.
-    """)
-    sys.exit()
-except (DistributionNotFound, VersionConflict):
-    pass
 
 PACKAGE = "allure-pytest"
 
 classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Framework :: Pytest',
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: Apache Software License',
-    'Topic :: Software Development :: Quality Assurance',
-    'Topic :: Software Development :: Testing',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'Programming Language :: Python :: 3.13',
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 setup_requires = [
-    "setuptools_scm"
+    "setuptools_scm<10"
 ]
 
 
@@ -78,5 +66,5 @@ def main():
         install_requires=install_requires
     )
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/allure-pytest/src/helper.py b/allure-pytest/src/helper.py
index e6944ef4..a9df4b7e 100644
--- a/allure-pytest/src/helper.py
+++ b/allure-pytest/src/helper.py
@@ -10,7 +10,9 @@ class AllureTitleHelper:
     def decorate_as_title(self, test_title):
         def decorator(func):
             # pytest.fixture wraps function, so we need to get it directly
-            if getattr(func, '__pytest_wrapped__', None):
+            if hasattr(func, "_get_wrapped_function"):  # pytest >= 8.4
+                function = func._get_wrapped_function()
+            elif hasattr(func, "__pytest_wrapped__"):  # pytest < 8.4
                 function = func.__pytest_wrapped__.obj
             else:
                 function = func
diff --git a/allure-pytest/src/listener.py b/allure-pytest/src/listener.py
index 11153630..0685b61a 100644
--- a/allure-pytest/src/listener.py
+++ b/allure-pytest/src/listener.py
@@ -19,6 +19,7 @@
 from allure_pytest.utils import allure_description, allure_description_html
 from allure_pytest.utils import allure_labels, allure_links, pytest_markers
 from allure_pytest.utils import allure_full_name, allure_package, allure_name
+from allure_pytest.utils import allure_title_path
 from allure_pytest.utils import allure_suite_labels
 from allure_pytest.utils import get_status, get_status_details
 from allure_pytest.utils import get_outcome_status, get_outcome_status_details
@@ -109,6 +110,7 @@ def pytest_runtest_setup(self, item):
         test_result.name = allure_name(item, params, param_id)
         full_name = allure_full_name(item)
         test_result.fullName = full_name
+        test_result.titlePath = [*allure_title_path(item)]
         test_result.testCaseId = md5(full_name)
         test_result.description = allure_description(item)
         test_result.descriptionHtml = allure_description_html(item)
@@ -147,14 +149,14 @@ def pytest_runtest_teardown(self, item):
         self.__apply_default_suites(item, test_result)
         test_result.labels.append(Label(name=LabelType.HOST, value=self._host))
         test_result.labels.append(Label(name=LabelType.THREAD, value=self._thread))
-        test_result.labels.append(Label(name=LabelType.FRAMEWORK, value='pytest'))
+        test_result.labels.append(Label(name=LabelType.FRAMEWORK, value="pytest"))
         test_result.labels.append(Label(name=LabelType.LANGUAGE, value=platform_label()))
-        test_result.labels.append(Label(name='package', value=allure_package(item)))
+        test_result.labels.append(Label(name="package", value=allure_package(item)))
         test_result.links.extend([Link(link_type, url, name) for link_type, url, name in allure_links(item)])
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_fixture_setup(self, fixturedef, request):
-        fixture_name = getattr(fixturedef.func, '__allure_display_name__', fixturedef.argname)
+        fixture_name = getattr(fixturedef.func, "__allure_display_name__", fixturedef.argname)
 
         container_uuid = self._cache.get(fixturedef)
 
@@ -176,16 +178,16 @@ def pytest_fixture_setup(self, fixturedef, request):
                                                status=get_outcome_status(outcome),
                                                statusDetails=get_outcome_status_details(outcome))
 
-        finalizers = getattr(fixturedef, '_finalizers', [])
+        finalizers = getattr(fixturedef, "_finalizers", [])
         for index, finalizer in enumerate(finalizers):
             finalizer_name = getattr(finalizer, "__name__", index)
-            name = f'{fixture_name}::{finalizer_name}'
+            name = f"{fixture_name}::{finalizer_name}"
             finalizers[index] = allure_commons.fixture(finalizer, parent_uuid=container_uuid, name=name)
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_fixture_post_finalizer(self, fixturedef):
         yield
-        if hasattr(fixturedef, 'cached_result') and self._cache.get(fixturedef):
+        if hasattr(fixturedef, "cached_result") and self._cache.get(fixturedef):
             container_uuid = self._cache.pop(fixturedef)
             self.allure_logger.stop_group(container_uuid, stop=now())
 
@@ -201,9 +203,9 @@ def pytest_runtest_makereport(self, item, call):
 
         if call.excinfo:
             message = call.excinfo.exconly()
-            if hasattr(report, 'wasxfail'):
+            if hasattr(report, "wasxfail"):
                 reason = report.wasxfail
-                message = (f'XFAIL {reason}' if reason else 'XFAIL') + '\n\n' + message
+                message = (f"XFAIL {reason}" if reason else "XFAIL") + "\n\n" + message
             trace = report.longreprtext
             status_details = StatusDetails(
                 message=message,
@@ -213,21 +215,21 @@ def pytest_runtest_makereport(self, item, call):
             if (status != Status.SKIPPED and _exception_brokes_test(exception)):
                 status = Status.BROKEN
 
-        if status == Status.PASSED and hasattr(report, 'wasxfail'):
+        if status == Status.PASSED and hasattr(report, "wasxfail"):
             reason = report.wasxfail
-            message = f'XPASS {reason}' if reason else 'XPASS'
+            message = f"XPASS {reason}" if reason else "XPASS"
             status_details = StatusDetails(message=message)
 
-        if report.when == 'setup':
+        if report.when == "setup":
             test_result.status = status
             test_result.statusDetails = status_details
 
-        if report.when == 'call':
+        if report.when == "call":
             if test_result.status == Status.PASSED:
                 test_result.status = status
                 test_result.statusDetails = status_details
 
-        if report.when == 'teardown':
+        if report.when == "teardown":
             if status in (Status.FAILED, Status.BROKEN) and test_result.status == Status.PASSED:
                 test_result.status = status
                 test_result.statusDetails = status_details
@@ -255,6 +257,30 @@ def attach_data(self, body, name, attachment_type, extension):
     def attach_file(self, source, name, attachment_type, extension):
         self.allure_logger.attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)
 
+    @allure_commons.hookimpl
+    def global_attach_data(self, body, name, attachment_type, extension):
+        self.allure_logger.global_attach_data(
+            uuid4(),
+            body,
+            name=name,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+
+    @allure_commons.hookimpl
+    def global_attach_file(self, source, name, attachment_type, extension):
+        self.allure_logger.global_attach_file(
+            uuid4(),
+            source,
+            name=name,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+
+    @allure_commons.hookimpl
+    def global_error(self, message, trace, status):
+        self.allure_logger.global_error(message=message, trace=trace, status=status)
+
     @allure_commons.hookimpl
     def add_title(self, test_title):
         test_result = self.allure_logger.get_test(None)
@@ -308,11 +334,11 @@ def add_parameter(self, name, value, excluded, mode: ParameterMode):
 
     @staticmethod
     def __get_pytest_params(item):
-        return item.callspec.params if hasattr(item, 'callspec') else {}
+        return item.callspec.params if hasattr(item, "callspec") else {}
 
     @staticmethod
     def __get_pytest_param_id(item):
-        return item.callspec.id if hasattr(item, 'callspec') else None
+        return item.callspec.id if hasattr(item, "callspec") else None
 
     def __apply_default_suites(self, item, test_result):
         default_suites = allure_suite_labels(item)
diff --git a/allure-pytest/src/plugin.py b/allure-pytest/src/plugin.py
index 2771722f..9efc358b 100644
--- a/allure-pytest/src/plugin.py
+++ b/allure-pytest/src/plugin.py
@@ -17,24 +17,24 @@
 
 
 def pytest_addoption(parser):
-    parser.getgroup("reporting").addoption('--alluredir',
+    parser.getgroup("reporting").addoption("--alluredir",
                                            action="store",
                                            dest="allure_report_dir",
                                            metavar="DIR",
                                            default=None,
                                            help="Generate Allure report in the specified directory (may not exist)")
 
-    parser.getgroup("reporting").addoption('--clean-alluredir',
+    parser.getgroup("reporting").addoption("--clean-alluredir",
                                            action="store_true",
                                            dest="clean_alluredir",
                                            help="Clean alluredir folder if it exists")
 
-    parser.getgroup("reporting").addoption('--allure-no-capture',
+    parser.getgroup("reporting").addoption("--allure-no-capture",
                                            action="store_false",
                                            dest="attach_capture",
                                            help="Do not attach pytest captured logging/stdout/stderr to report")
 
-    parser.getgroup("reporting").addoption('--inversion',
+    parser.getgroup("reporting").addoption("--inversion",
                                            action="store",
                                            dest="inversion",
                                            default=False,
@@ -42,21 +42,21 @@ def pytest_addoption(parser):
 
     def label_type(type_name, legal_values=set()):
         def a_label_type(string):
-            atoms = set(string.split(','))
+            atoms = set(string.split(","))
             if type_name is LabelType.SEVERITY:
                 if not atoms <= legal_values:
-                    raise argparse.ArgumentTypeError('Illegal {} values: {}, only [{}] are allowed'.format(
+                    raise argparse.ArgumentTypeError("Illegal {} values: {}, only [{}] are allowed".format(
                         type_name,
-                        ', '.join(atoms - legal_values),
-                        ', '.join(legal_values)
+                        ", ".join(atoms - legal_values),
+                        ", ".join(legal_values)
                     ))
                 return set((type_name, allure.severity_level(atom)) for atom in atoms)
             return set((type_name, atom) for atom in atoms)
         return a_label_type
 
     severities = [x.value for x in list(allure.severity_level)]
-    formatted_severities = ', '.join(severities)
-    parser.getgroup("general").addoption('--allure-severities',
+    formatted_severities = ", ".join(severities)
+    parser.getgroup("general").addoption("--allure-severities",
                                          action="store",
                                          dest="allure_severities",
                                          metavar="SEVERITIES_SET",
@@ -66,7 +66,7 @@ def a_label_type(string):
                                          Tests only with these severities will be run.
                                          Possible values are: {formatted_severities}.""")
 
-    parser.getgroup("general").addoption('--allure-epics',
+    parser.getgroup("general").addoption("--allure-epics",
                                          action="store",
                                          dest="allure_epics",
                                          metavar="EPICS_SET",
@@ -75,7 +75,7 @@ def a_label_type(string):
                                          help="""Comma-separated list of epic names.
                                          Run tests that have at least one of the specified feature labels.""")
 
-    parser.getgroup("general").addoption('--allure-features',
+    parser.getgroup("general").addoption("--allure-features",
                                          action="store",
                                          dest="allure_features",
                                          metavar="FEATURES_SET",
@@ -84,7 +84,7 @@ def a_label_type(string):
                                          help="""Comma-separated list of feature names.
                                          Run tests that have at least one of the specified feature labels.""")
 
-    parser.getgroup("general").addoption('--allure-stories',
+    parser.getgroup("general").addoption("--allure-stories",
                                          action="store",
                                          dest="allure_stories",
                                          metavar="STORIES_SET",
@@ -93,7 +93,7 @@ def a_label_type(string):
                                          help="""Comma-separated list of story names.
                                          Run tests that have at least one of the specified story labels.""")
 
-    parser.getgroup("general").addoption('--allure-ids',
+    parser.getgroup("general").addoption("--allure-ids",
                                          action="store",
                                          dest="allure_ids",
                                          metavar="IDS_SET",
@@ -107,7 +107,7 @@ def cf_type(string):
         atoms = set(values.split(","))
         return [(type_name, atom) for atom in atoms]
 
-    parser.getgroup("general").addoption('--allure-label',
+    parser.getgroup("general").addoption("--allure-label",
                                          action="append",
                                          dest="allure_labels",
                                          metavar="LABELS_SET",
@@ -117,15 +117,15 @@ def cf_type(string):
                                          "Run tests that have at least one of the specified labels.""")
 
     def link_pattern(string):
-        pattern = string.split(':', 1)
+        pattern = string.split(":", 1)
         if not pattern[0]:
-            raise argparse.ArgumentTypeError('Link type is mandatory.')
+            raise argparse.ArgumentTypeError("Link type is mandatory.")
 
         if len(pattern) != 2:
-            raise argparse.ArgumentTypeError('Link pattern is mandatory')
+            raise argparse.ArgumentTypeError("Link pattern is mandatory")
         return pattern
 
-    parser.getgroup("general").addoption('--allure-link-pattern',
+    parser.getgroup("general").addoption("--allure-link-pattern",
                                          action="append",
                                          dest="allure_link_pattern",
                                          metavar="LINK_TYPE:LINK_PATTERN",
@@ -160,7 +160,7 @@ def pytest_configure(config):
     if report_dir:
         report_dir = os.path.abspath(report_dir)
         test_listener = AllureListener(config)
-        config.pluginmanager.register(test_listener, 'allure_listener')
+        config.pluginmanager.register(test_listener, "allure_listener")
         allure_commons.plugin_manager.register(test_listener)
         config.add_cleanup(cleanup_factory(test_listener))
 
diff --git a/allure-pytest/src/stash.py b/allure-pytest/src/stash.py
new file mode 100644
index 00000000..83e31b57
--- /dev/null
+++ b/allure-pytest/src/stash.py
@@ -0,0 +1,61 @@
+import pytest
+from functools import wraps
+
+HAS_STASH = hasattr(pytest, "StashKey")
+
+
+def create_stashkey_safe():
+    """
+    If pytest stash is available, returns a new stash key.
+    Otherwise, returns `None`.
+    """
+
+    return pytest.StashKey() if HAS_STASH else None
+
+
+def stash_get_safe(item, key):
+    """
+    If pytest stash is available and contains the key, retrieves the associated value.
+    Otherwise, returns `None`.
+    """
+
+    if HAS_STASH and key in item.stash:
+        return item.stash[key]
+
+
+def stash_set_safe(item: pytest.Item, key, value):
+    """
+    If pytest stash is available, associates the value with the key in the stash.
+    Otherwise, does nothing.
+    """
+
+    if HAS_STASH:
+        item.stash[key] = value
+
+
+def stashed(arg=None):
+    """
+    Cashes the result of the decorated function in the pytest item stash.
+    The first argument of the function must be a pytest item.
+
+    In pytest<7.0 the stash is not available, so the decorator does nothing.
+    """
+
+    key = create_stashkey_safe() if arg is None or callable(arg) else arg
+
+    def decorator(func):
+        if not HAS_STASH:
+            return func
+
+        @wraps(func)
+        def wrapper(item, *args, **kwargs):
+            if key in item.stash:
+                return item.stash[key]
+
+            value = func(item, *args, **kwargs)
+            item.stash[key] = value
+            return value
+
+        return wrapper
+
+    return decorator(arg) if callable(arg) else decorator
diff --git a/allure-pytest/src/utils.py b/allure-pytest/src/utils.py
index 1e07cb49..31ffb63f 100644
--- a/allure-pytest/src/utils.py
+++ b/allure-pytest/src/utils.py
@@ -1,16 +1,16 @@
 import pytest
-from itertools import chain, islice
-from allure_commons.utils import represent, SafeFormatter, md5
+from itertools import repeat
+from allure_commons.utils import SafeFormatter, md5
 from allure_commons.utils import format_exception, format_traceback
 from allure_commons.model2 import Status
 from allure_commons.model2 import StatusDetails
 from allure_commons.types import LabelType
+from allure_pytest.stash import stashed
 
-
-ALLURE_DESCRIPTION_MARK = 'allure_description'
-ALLURE_DESCRIPTION_HTML_MARK = 'allure_description_html'
-ALLURE_LABEL_MARK = 'allure_label'
-ALLURE_LINK_MARK = 'allure_link'
+ALLURE_DESCRIPTION_MARK = "allure_description"
+ALLURE_DESCRIPTION_HTML_MARK = "allure_description_html"
+ALLURE_LABEL_MARK = "allure_label"
+ALLURE_LINK_MARK = "allure_link"
 ALLURE_UNIQUE_LABELS = [
     LabelType.SEVERITY,
     LabelType.FRAMEWORK,
@@ -20,6 +20,33 @@
     LabelType.SUB_SUITE
 ]
 
+MARK_NAMES_TO_IGNORE = {
+    "usefixtures",
+    "filterwarnings",
+    "skip",
+    "skipif",
+    "xfail",
+    "parametrize",
+}
+
+
+class ParsedPytestNodeId:
+    def __init__(self, nodeid):
+        filepath, *class_names, function_segment = ensure_len(nodeid.split("::"), 2)
+        self.filepath = filepath
+        self.path_segments = filepath.split("/")
+        *parent_dirs, filename = ensure_len(self.path_segments, 1)
+        self.parent_package = ".".join(parent_dirs)
+        self.module = filename.rsplit(".", 1)[0]
+        self.package = ".".join(filter(None, [self.parent_package, self.module]))
+        self.class_names = class_names
+        self.test_function = function_segment.split("[", 1)[0]
+
+
+@stashed
+def parse_nodeid(item):
+    return ParsedPytestNodeId(item.nodeid)
+
 
 def get_marker_value(item, keyword):
     marker = item.get_closest_marker(keyword)
@@ -38,7 +65,7 @@ def allure_description(item):
     description = get_marker_value(item, ALLURE_DESCRIPTION_MARK)
     if description:
         return description
-    elif hasattr(item, 'function'):
+    elif hasattr(item, "function"):
         return item.function.__doc__
 
 
@@ -76,38 +103,23 @@ def allure_links(item):
 
 
 def format_allure_link(config, url, link_type):
-    pattern = dict(config.option.allure_link_pattern).get(link_type, '{}')
+    pattern = dict(config.option.allure_link_pattern).get(link_type, "{}")
     return pattern.format(url)
 
 
 def pytest_markers(item):
-    for keyword in item.keywords.keys():
-        if any([keyword.startswith('allure_'), keyword == 'parametrize']):
-            continue
-        marker = item.get_closest_marker(keyword)
-        if marker is None:
-            continue
+    for mark in item.iter_markers():
+        if should_convert_mark_to_tag(mark):
+            yield mark.name
 
-        yield mark_to_str(marker)
 
-
-def mark_to_str(marker):
-    args = [represent(arg) for arg in marker.args]
-    kwargs = [f'{key}={represent(value)}' for key, value in marker.kwargs.items()]
-    if marker.name in ('filterwarnings', 'skip', 'skipif', 'xfail', 'usefixtures', 'tryfirst', 'trylast'):
-        markstr = f'@pytest.mark.{marker.name}'
-    else:
-        markstr = str(marker.name)
-    if args or kwargs:
-        parameters = ', '.join(args + kwargs)
-        markstr = f'{markstr}({parameters})'
-    return markstr
+def should_convert_mark_to_tag(mark):
+    return mark.name not in MARK_NAMES_TO_IGNORE and \
+        not mark.args and not mark.kwargs
 
 
 def allure_package(item):
-    parts = item.nodeid.split('::')
-    path = parts[0].rsplit('.', 1)[0]
-    return path.replace('/', '.')
+    return parse_nodeid(item).package
 
 
 def allure_name(item, parameters, param_id=None):
@@ -126,27 +138,41 @@ def allure_name(item, parameters, param_id=None):
 
 
 def allure_full_name(item: pytest.Item):
-    package = allure_package(item)
-    class_name = f".{item.parent.name}" if isinstance(item.parent, pytest.Class) else ''
-    test = item.originalname if isinstance(item, pytest.Function) else item.name.split("[")[0]
-    full_name = f'{package}{class_name}#{test}'
+    nodeid = parse_nodeid(item)
+    class_part = ("." + ".".join(nodeid.class_names)) if nodeid.class_names else ""
+    test = item.originalname if isinstance(item, pytest.Function) else nodeid.test_function
+    full_name = f"{nodeid.package}{class_part}#{test}"
     return full_name
 
 
+def allure_title_path(item):
+    nodeid = parse_nodeid(item)
+    return list(
+        filter(None, [*nodeid.path_segments, *nodeid.class_names]),
+    )
+
+
+def ensure_len(value, min_length, fill_value=None):
+    yield from value
+    yield from repeat(fill_value, min_length - len(value))
+
+
 def allure_suite_labels(item):
-    head, possibly_clazz, tail = islice(chain(item.nodeid.split('::'), [None], [None]), 3)
-    clazz = possibly_clazz if tail else None
-    file_name, path = islice(chain(reversed(head.rsplit('/', 1)), [None]), 2)
-    module = file_name.split('.')[0]
-    package = path.replace('/', '.') if path else None
-    pairs = dict(zip([LabelType.PARENT_SUITE, LabelType.SUITE, LabelType.SUB_SUITE], [package, module, clazz]))
-    labels = dict(allure_labels(item))
-    default_suite_labels = []
-    for label, value in pairs.items():
-        if label not in labels.keys() and value:
-            default_suite_labels.append((label, value))
+    nodeid = parse_nodeid(item)
+
+    default_suite_labels = {
+        LabelType.PARENT_SUITE: nodeid.parent_package,
+        LabelType.SUITE: nodeid.module,
+        LabelType.SUB_SUITE: " > ".join(nodeid.class_names),
+    }
+
+    existing_labels = dict(allure_labels(item))
+    resolved_default_suite_labels = []
+    for label, value in default_suite_labels.items():
+        if label not in existing_labels and value:
+            resolved_default_suite_labels.append((label, value))
 
-    return default_suite_labels
+    return resolved_default_suite_labels
 
 
 def get_outcome_status(outcome):
@@ -177,7 +203,7 @@ def get_status_details(exception_type, exception, exception_traceback):
 
 
 def get_pytest_report_status(pytest_report):
-    pytest_statuses = ('failed', 'passed', 'skipped')
+    pytest_statuses = ("failed", "passed", "skipped")
     statuses = (Status.FAILED, Status.PASSED, Status.SKIPPED)
     for pytest_status, status in zip(pytest_statuses, statuses):
         if getattr(pytest_report, pytest_status):
diff --git a/allure-python-commons-test/pyproject.toml b/allure-python-commons-test/pyproject.toml
index cc2b9ab5..a817d869 100644
--- a/allure-python-commons-test/pyproject.toml
+++ b/allure-python-commons-test/pyproject.toml
@@ -1,3 +1,3 @@
 [tool.poe.tasks]
-linter = "flake8 ./src"
+linter = "ruff check"
 tests = "python -m doctest ./src/*.py"
diff --git a/allure-python-commons-test/setup.py b/allure-python-commons-test/setup.py
index bfcaddca..3d5eb5d7 100644
--- a/allure-python-commons-test/setup.py
+++ b/allure-python-commons-test/setup.py
@@ -4,19 +4,19 @@
 PACKAGE = "allure-python-commons-test"
 
 classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: Apache Software License',
-    'Topic :: Software Development :: Quality Assurance',
-    'Topic :: Software Development :: Testing',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'Programming Language :: Python :: 3.13',
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 install_requires = [
@@ -32,7 +32,7 @@ def main():
     setup(
         name=PACKAGE,
         use_scm_version={"root": "..", "relative_to": __file__},
-        setup_requires=['setuptools_scm'],
+        setup_requires=["setuptools_scm<10"],
         description=(
             "A collection of PyHamcrest matchers to test Allure adapters for "
             "Python test frameworks"
@@ -53,5 +53,5 @@ def main():
         install_requires=install_requires
     )
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/allure-python-commons-test/src/container.py b/allure-python-commons-test/src/container.py
index 50aa1e6b..ba9b7b0c 100644
--- a/allure-python-commons-test/src/container.py
+++ b/allure-python-commons-test/src/container.py
@@ -11,16 +11,16 @@ def __init__(self, report, *matchers):
 
     def _matches(self, item):
         return has_property(
-            'test_containers',
+            "test_containers",
             has_item(
                 all_of(
-                    has_entry('children', has_item(item['uuid'])),
+                    has_entry("children", has_item(item["uuid"])),
                     *self.matchers
                 )
             )).matches(self.report)
 
     def describe_to(self, description):
-        description.append_text('describe me later').append_list('[', ', ', ']', self.matchers)
+        description.append_text("describe me later").append_list("[", ", ", "]", self.matchers)
 
     def describe_mismatch(self, item, mismatch_description):
         self.matches(item, mismatch_description)
@@ -84,14 +84,14 @@ def __init__(self, *args):
     @staticmethod
     def _test_case_id_by_name(report, test_case_name):
         for test_case in report.test_cases:
-            if test_case['fullName'].endswith(test_case_name):
-                return test_case['uuid']
+            if test_case["fullName"].endswith(test_case_name):
+                return test_case["uuid"]
 
     def _matches(self, report):
-        return has_property('test_containers',
+        return has_property("test_containers",
                             has_item(
                                      all_of(
-                                            has_entry('children',
+                                            has_entry("children",
                                                       all_of(
                                                              *[has_item(self._test_case_id_by_name(report, name))
                                                                for name in self.test_case_names]
@@ -103,7 +103,7 @@ def _matches(self, report):
 
     # TODO better describe
     def describe_to(self, description):
-        description.append_text('test_case has group')
+        description.append_text("test_case has group")
 
 
 def has_same_container(*args):
@@ -156,7 +156,7 @@ def has_fixture(section, name, *matchers):
         section,
         has_item(
             all_of(
-                has_entry('name', equal_to(name)),
+                has_entry("name", equal_to(name) if isinstance(name, str) else name),
                 *matchers
             )
         )
@@ -164,8 +164,8 @@ def has_fixture(section, name, *matchers):
 
 
 def has_before(name, *matchers):
-    return has_fixture('befores', name, *matchers)
+    return has_fixture("befores", name, *matchers)
 
 
 def has_after(name, *matchers):
-    return has_fixture('afters', name, *matchers)
+    return has_fixture("afters", name, *matchers)
diff --git a/allure-python-commons-test/src/label.py b/allure-python-commons-test/src/label.py
index 15d9e3d2..364d43a1 100644
--- a/allure-python-commons-test/src/label.py
+++ b/allure-python-commons-test/src/label.py
@@ -7,55 +7,55 @@ def has_label(name, value=None):
     if value is None:
         value = anything()
     return has_entry(
-        'labels',
+        "labels",
         has_item(
             all_of(
-                has_entry('name', name),
-                has_entry('value', value)
+                has_entry("name", name),
+                has_entry("value", value)
             )
         )
     )
 
 
 def has_severity(level):
-    return has_label('severity', level)
+    return has_label("severity", level)
 
 
 def has_epic(feature):
-    return has_label('epic', feature)
+    return has_label("epic", feature)
 
 
 def has_feature(feature):
-    return has_label('feature', feature)
+    return has_label("feature", feature)
 
 
 def has_story(story):
-    return has_label('story', story)
+    return has_label("story", story)
 
 
 def has_tag(tag):
-    return has_label('tag', tag)
+    return has_label("tag", tag)
 
 
 def has_package(package):
-    return has_label('package', package)
+    return has_label("package", package)
 
 
 def has_suite(suite):
-    return has_label('suite', suite)
+    return has_label("suite", suite)
 
 
 def has_parent_suite(parent_suite):
-    return has_label('parentSuite', parent_suite)
+    return has_label("parentSuite", parent_suite)
 
 
 def has_sub_suite(sub_suite):
-    return has_label('subSuite', sub_suite)
+    return has_label("subSuite", sub_suite)
 
 
 def has_allure_id(allure_id):
-    return has_label('as_id', allure_id)
+    return has_label("as_id", allure_id)
 
 
 def has_manual(allure_id):
-    return has_label('ALLURE_MANUAL', allure_id)
+    return has_label("ALLURE_MANUAL", allure_id)
diff --git a/allure-python-commons-test/src/report.py b/allure-python-commons-test/src/report.py
index 82036ea3..1db9413d 100644
--- a/allure-python-commons-test/src/report.py
+++ b/allure-python-commons-test/src/report.py
@@ -84,21 +84,27 @@ def __init__(self, result):
         self.test_cases = [
             json.load(file) for _, file in self._report_items(
                 result,
-                '*result.json'
+                "*result.json"
             )
         ]
         self.test_containers = [
             json.load(file) for _, file in self._report_items(
                 result,
-                '*container.json'
+                "*container.json"
             )
         ]
         self.attachments = {
             name: file.read() for name, file in self._report_items(
                 result,
-                '*attachment.*'
+                "*attachment.*"
             )
         }
+        self.globals = [
+            json.load(file) for _, file in self._report_items(
+                result,
+                "*globals.json"
+            )
+        ]
 
     @staticmethod
     def _report_items(report_dir, glob):
@@ -111,12 +117,12 @@ def _report_items(report_dir, glob):
 
 def has_test_case(name, *matchers):
     return has_property(
-        'test_cases',
+        "test_cases",
         has_item(
             all_of(
                 any_of(
-                    has_entry('fullName', ends_with(name)),
-                    has_entry('name', starts_with(name))
+                    has_entry("fullName", ends_with(name)),
+                    has_entry("name", starts_with(name))
                 ),
                 *matchers
             )
@@ -129,7 +135,7 @@ def __init__(self, *matchers):
         self.matchers = matchers
 
     def _matches(self, item):
-        return has_property('test_cases',
+        return has_property("test_cases",
                             only_contains(any_of(*self.matchers))
                             ).matches(item)
 
@@ -160,19 +166,19 @@ def _matches(self, item):
 
     def describe_to(self, description):
         description.append_text(
-            f'exactly {self.num} item(s) matching '
+            f"exactly {self.num} item(s) matching "
         ).append_text(self.matcher)
 
 
 def has_only_n_test_cases(name, num, *matchers):
     return has_property(
-        'test_cases',
+        "test_cases",
         ContainsExactly(
             num,
             all_of(
                 any_of(
-                    has_entry('fullName', ends_with(name)),
-                    has_entry('name', ends_with(name))
+                    has_entry("fullName", ends_with(name)),
+                    has_entry("name", ends_with(name))
                 ),
                 *matchers
             )
diff --git a/allure-python-commons-test/src/result.py b/allure-python-commons-test/src/result.py
index 84bb6094..7012234f 100644
--- a/allure-python-commons-test/src/result.py
+++ b/allure-python-commons-test/src/result.py
@@ -71,23 +71,30 @@
 
 
 def has_title(title):
-    return has_entry('name', title)
+    return has_entry("name", title)
+
+
+def has_title_path(*matchers):
+    return has_entry(
+        "titlePath",
+        contains_exactly(*matchers),
+    )
 
 
 def has_description(*matchers):
-    return has_entry('description', all_of(*matchers))
+    return has_entry("description", all_of(*matchers))
 
 
 def has_description_html(*matchers):
-    return has_entry('descriptionHtml', all_of(*matchers))
+    return has_entry("descriptionHtml", all_of(*matchers))
 
 
 def has_step(name, *matchers):
     return has_entry(
-        'steps',
+        "steps",
         has_item(
             all_of(
-                has_entry('name', equal_to(name)),
+                has_entry("name", equal_to(name)),
                 *matchers
             )
         )
@@ -103,10 +110,10 @@ def with_steps(*matchers):
 
 def get_parameter_matcher(name, *matchers):
     return has_entry(
-        'parameters',
+        "parameters",
         has_item(
             all_of(
-                has_entry('name', equal_to(name)),
+                has_entry("name", equal_to(name)),
                 *matchers
             )
         )
@@ -116,7 +123,7 @@ def get_parameter_matcher(name, *matchers):
 def has_parameter(name, value, *matchers):
     return get_parameter_matcher(
         name,
-        has_entry('value', equal_to(value)),
+        has_entry("value", equal_to(value)),
         *matchers
     )
 
@@ -141,12 +148,12 @@ def resolve_link_attr_matcher(key, value):
 
 def has_link(url, link_type=None, name=None):
     return has_entry(
-        'links',
+        "links",
         has_item(
             all_of(
                 *[
                     resolve_link_attr_matcher(key, value) for key, value in zip(
-                        ('url', 'type', 'name'),
+                        ("url", "type", "name"),
                         (url, link_type, name)
                     ) if value is not None
                 ]
@@ -156,21 +163,21 @@ def has_link(url, link_type=None, name=None):
 
 
 def has_issue_link(url, name=None):
-    return has_link(url, link_type='issue', name=name)
+    return has_link(url, link_type="issue", name=name)
 
 
 def has_test_case_link(url, name=None):
-    return has_link(url, link_type='tms', name=name)
+    return has_link(url, link_type="tms", name=name)
 
 
 def has_attachment(attach_type=None, name=None):
     return has_entry(
-        'attachments',
+        "attachments",
         has_item(
             all_of(
-                has_entry('source', anything()),
-                has_entry('type', attach_type) if attach_type else anything(),
-                has_entry('name', name) if name else anything()
+                has_entry("source", anything()),
+                has_entry("type", attach_type) if attach_type else anything(),
+                has_entry("name", name) if name else anything()
             )
         )
     )
@@ -183,44 +190,85 @@ def has_attachment_with_content(
     name=None
 ):
     return has_entry(
-        'attachments',
+        "attachments",
+        has_item(
+            all_of(
+                has_entry("name", name) if name else anything(),
+                has_entry("type", attach_type) if attach_type else anything(),
+                has_entry("source", maps_to(attachments, content_matcher))
+            )
+        )
+    )
+
+
+def has_global_attachment_with_content(
+    attachments,
+    content_matcher,
+    attach_type=None,
+    name=None
+):
+    return has_entry(
+        "attachments",
         has_item(
             all_of(
-                has_entry('name', name) if name else anything(),
-                has_entry('type', attach_type) if attach_type else anything(),
-                has_entry('source', maps_to(attachments, content_matcher))
+                has_entry("name", name) if name else anything(),
+                has_entry("type", attach_type) if attach_type else anything(),
+                has_entry("timestamp", not_none()),
+                has_entry("source", maps_to(attachments, content_matcher))
             )
         )
     )
 
 
 def with_id():
-    return has_entry('uuid', not_none())
+    return has_entry("uuid", not_none())
 
 
 def with_status(status):
-    return has_entry('status', status)
+    return has_entry("status", status)
 
 
 def has_status_details(*matchers):
-    return has_entry('statusDetails', all_of(*matchers))
+    return has_entry("statusDetails", all_of(*matchers))
+
+
+def has_global_error(*matchers):
+    return has_entry(
+        "errors",
+        has_item(
+            all_of(
+                has_entry("timestamp", not_none()),
+                *matchers
+            )
+        )
+    )
 
 
 def with_message_contains(string):
-    return has_entry('message', contains_string(string))
+    return has_entry("message", contains_string(string))
 
 
 def with_trace_contains(string):
-    return has_entry('trace', contains_string(string))
+    return has_entry("trace", contains_string(string))
 
+def with_no_trace():
+    return not_(has_entry("trace", anything()))
 
 def with_excluded():
-    return has_entry('excluded', True)
+    return has_entry("excluded", True)
 
 
 def with_mode(mode):
-    return has_entry('mode', mode)
+    return has_entry("mode", mode)
 
 
 def has_history_id(matcher=None):
-    return has_entry('historyId', matcher or anything())
+    return has_entry("historyId", matcher or anything())
+
+
+def has_test_case_id(matcher=None):
+    return has_entry("testCaseId", matcher or anything())
+
+
+def has_full_name(matcher):
+    return has_entry("fullName", matcher)
diff --git a/allure-python-commons/pyproject.toml b/allure-python-commons/pyproject.toml
index 9fd4df26..3111b705 100644
--- a/allure-python-commons/pyproject.toml
+++ b/allure-python-commons/pyproject.toml
@@ -1,3 +1,3 @@
 [tool.poe.tasks]
-linter = "flake8 --extend-ignore=A001,A002,A003 ./src"
+linter = "ruff check"
 tests = "python -m doctest ./src/allure_commons/*.py"
diff --git a/allure-python-commons/setup.py b/allure-python-commons/setup.py
index 75bb2332..f20db001 100644
--- a/allure-python-commons/setup.py
+++ b/allure-python-commons/setup.py
@@ -33,7 +33,7 @@ def main():
     setup(
         name=PACKAGE,
         use_scm_version={"root": "..", "relative_to": __file__},
-        setup_requires=["setuptools_scm"],
+        setup_requires=["setuptools_scm<10"],
         description=(
             "Contains the API for end users as well as helper functions and "
             "classes to build Allure adapters for Python test frameworks"
diff --git a/allure-python-commons/src/allure/__init__.py b/allure-python-commons/src/allure/__init__.py
index c30329a6..86feb62f 100644
--- a/allure-python-commons/src/allure/__init__.py
+++ b/allure-python-commons/src/allure/__init__.py
@@ -10,34 +10,40 @@
 from allure_commons._allure import Dynamic as dynamic
 from allure_commons._allure import step
 from allure_commons._allure import attach
+from allure_commons._allure import global_attach
+from allure_commons._allure import global_error
 from allure_commons._allure import manual
 from allure_commons.types import Severity as severity_level
 from allure_commons.types import AttachmentType as attachment_type
 from allure_commons.types import ParameterMode as parameter_mode
+from allure_commons.types import ErrorStatus as error_status
 
 
 __all__ = [
-    'title',
-    'description',
-    'description_html',
-    'label',
-    'severity',
-    'suite',
-    'parent_suite',
-    'sub_suite',
-    'tag',
-    'id',
-    'epic',
-    'feature',
-    'story',
-    'link',
-    'issue',
-    'testcase',
-    'manual',
-    'step',
-    'dynamic',
-    'severity_level',
-    'attach',
-    'attachment_type',
-    'parameter_mode'
+    "title",
+    "description",
+    "description_html",
+    "label",
+    "severity",
+    "suite",
+    "parent_suite",
+    "sub_suite",
+    "tag",
+    "id",
+    "epic",
+    "feature",
+    "story",
+    "link",
+    "issue",
+    "testcase",
+    "manual",
+    "step",
+    "dynamic",
+    "severity_level",
+    "attach",
+    "global_attach",
+    "global_error",
+    "attachment_type",
+    "parameter_mode",
+    "error_status"
 ]
diff --git a/allure-python-commons/src/allure_commons/__init__.py b/allure-python-commons/src/allure_commons/__init__.py
index 111c2d06..e480acea 100644
--- a/allure-python-commons/src/allure_commons/__init__.py
+++ b/allure-python-commons/src/allure_commons/__init__.py
@@ -1,12 +1,12 @@
-from allure_commons._hooks import hookimpl  # noqa: F401
-from allure_commons._core import plugin_manager  # noqa: F401
-from allure_commons._allure import fixture  # noqa: F401
-from allure_commons._allure import test  # noqa: F401
+from allure_commons._hooks import hookimpl
+from allure_commons._core import plugin_manager
+from allure_commons._allure import fixture
+from allure_commons._allure import test
 
 
 __all__ = [
-    'hookimpl',
-    'plugin_manager',
-    'fixture',
-    'test'
+    "hookimpl",
+    "plugin_manager",
+    "fixture",
+    "test"
 ]
diff --git a/allure-python-commons/src/allure_commons/_allure.py b/allure-python-commons/src/allure_commons/_allure.py
index b7bbe2a5..731786dc 100644
--- a/allure-python-commons/src/allure_commons/_allure.py
+++ b/allure-python-commons/src/allure_commons/_allure.py
@@ -2,8 +2,9 @@
 from typing import Any, Callable, TypeVar, Union, overload
 
 from allure_commons._core import plugin_manager
-from allure_commons.types import LabelType, LinkType, ParameterMode
+from allure_commons.types import LabelType, LinkType, ParameterMode, ErrorStatus
 from allure_commons.utils import uuid4
+from allure_commons.utils import format_exception, format_traceback
 from allure_commons.utils import func_parameters, represent
 
 _TFunc = TypeVar("_TFunc", bound=Callable[..., Any])
@@ -125,7 +126,7 @@ def tag(*tags):
         Dynamic.label(LabelType.TAG, *tags)
 
     @staticmethod
-    def id(id):  # noqa: A003,A002
+    def id(id):  # noqa: A002
         Dynamic.label(LabelType.ID, id)
 
     @staticmethod
@@ -216,6 +217,56 @@ def file(self, source, name=None, attachment_type=None, extension=None):
 attach = Attach()
 
 
+class GlobalAttach:
+
+    def __call__(self, body, name=None, attachment_type=None, extension=None):
+        plugin_manager.hook.global_attach_data(
+            body=body,
+            name=name,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+
+    def file(self, source, name=None, attachment_type=None, extension=None):
+        plugin_manager.hook.global_attach_file(
+            source=source,
+            name=name,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+
+
+global_attach = GlobalAttach()
+
+@overload
+def global_error(
+    value: BaseException,
+    *,
+    status: ErrorStatus = ErrorStatus.BROKEN
+) -> None:
+    ...
+
+
+@overload
+def global_error(
+    value: str,
+    trace: Union[str, None] = None,
+    *,
+    status: ErrorStatus = ErrorStatus.BROKEN
+) -> None:
+    ...
+
+
+def global_error(value, trace=None, *, status: ErrorStatus = ErrorStatus.BROKEN):
+    message = None
+    if isinstance(value, BaseException):
+        message = format_exception(type(value), value)
+        trace = format_traceback(value.__traceback__)
+    else:
+        message = value
+    plugin_manager.hook.global_error(message=message, trace=trace, status=status)
+
+
 class fixture:
     def __init__(self, fixture_function, parent_uuid=None, name=None):
         self._fixture_function = fixture_function
diff --git a/allure-python-commons/src/allure_commons/_core.py b/allure-python-commons/src/allure_commons/_core.py
index 40d9deaf..8687891c 100644
--- a/allure-python-commons/src/allure_commons/_core.py
+++ b/allure-python-commons/src/allure_commons/_core.py
@@ -8,7 +8,7 @@ class MetaPluginManager(type):
     @staticmethod
     def get_plugin_manager():
         if not MetaPluginManager._plugin_manager:
-            MetaPluginManager._plugin_manager = PluginManager('allure')
+            MetaPluginManager._plugin_manager = PluginManager("allure")
             MetaPluginManager._plugin_manager.add_hookspecs(_hooks.AllureUserHooks)
             MetaPluginManager._plugin_manager.add_hookspecs(_hooks.AllureDeveloperHooks)
 
diff --git a/allure-python-commons/src/allure_commons/_hooks.py b/allure-python-commons/src/allure_commons/_hooks.py
index 0ff19a27..0ef73b8e 100644
--- a/allure-python-commons/src/allure_commons/_hooks.py
+++ b/allure-python-commons/src/allure_commons/_hooks.py
@@ -66,6 +66,18 @@ def attach_data(self, body, name, attachment_type, extension):
     def attach_file(self, source, name, attachment_type, extension):
         """ attach file """
 
+    @hookspec
+    def global_attach_data(self, body, name, attachment_type, extension):
+        """ attach global data """
+
+    @hookspec
+    def global_attach_file(self, source, name, attachment_type, extension):
+        """ attach global file """
+
+    @hookspec
+    def global_error(self, message, trace, status):
+        """ global error """
+
 
 class AllureDeveloperHooks:
 
@@ -100,3 +112,7 @@ def report_attached_file(self, source, file_name):
     @hookspec
     def report_attached_data(self, body, file_name):
         """ reporting """
+
+    @hookspec
+    def report_globals(self, globals_item):
+        """ reporting """
diff --git a/allure-python-commons/src/allure_commons/lifecycle.py b/allure-python-commons/src/allure_commons/lifecycle.py
index 2e730e2e..b97d6b82 100644
--- a/allure-python-commons/src/allure_commons/lifecycle.py
+++ b/allure-python-commons/src/allure_commons/lifecycle.py
@@ -4,10 +4,12 @@
 from allure_commons.model2 import TestResultContainer
 from allure_commons.model2 import TestResult
 from allure_commons.model2 import Attachment, ATTACHMENT_PATTERN
+from allure_commons.model2 import GlobalAttachment, GlobalError, Globals
 from allure_commons.model2 import TestStepResult
 from allure_commons.model2 import ExecutableItem
 from allure_commons.model2 import TestBeforeResult
 from allure_commons.model2 import TestAfterResult
+from allure_commons.types import ErrorStatus
 from allure_commons.utils import uuid4
 from allure_commons.utils import now
 from allure_commons.types import AttachmentType
@@ -124,14 +126,11 @@ def stop_after_fixture(self, uuid=None):
             fixture.stop = now()
 
     def _attach(self, uuid, name=None, attachment_type=None, extension=None, parent_uuid=None):
-        mime_type = attachment_type
-        extension = extension if extension else 'attach'
-
-        if type(attachment_type) is AttachmentType:
-            extension = attachment_type.extension
-            mime_type = attachment_type.mime_type
-
-        file_name = ATTACHMENT_PATTERN.format(prefix=uuid, ext=extension)
+        file_name, mime_type = self.__resolve_attachment_filename_and_type(
+            uuid,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
         attachment = Attachment(source=file_name, name=name, type=mime_type)
         last_uuid = parent_uuid if parent_uuid else self._last_item_uuid(ExecutableItem)
         self._items[last_uuid].attachments.append(attachment)
@@ -147,3 +146,41 @@ def attach_data(self, uuid, body, name=None, attachment_type=None, extension=Non
         file_name = self._attach(uuid, name=name, attachment_type=attachment_type,
                                  extension=extension, parent_uuid=parent_uuid)
         plugin_manager.hook.report_attached_data(body=body, file_name=file_name)
+
+    def global_attach_file(self, uuid, source, name=None, attachment_type=None, extension=None):
+        file_name, mime_type = self.__resolve_attachment_filename_and_type(
+            uuid,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+        plugin_manager.hook.report_attached_file(source=source, file_name=file_name)
+        plugin_manager.hook.report_globals(globals_item=Globals(attachments=[
+            GlobalAttachment(source=file_name, name=name, type=mime_type, timestamp=now())
+        ]))
+
+    def global_attach_data(self, uuid, body, name=None, attachment_type=None, extension=None):
+        file_name, mime_type = self.__resolve_attachment_filename_and_type(
+            uuid,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+        plugin_manager.hook.report_attached_data(body=body, file_name=file_name)
+        plugin_manager.hook.report_globals(globals_item=Globals(attachments=[
+            GlobalAttachment(source=file_name, name=name, type=mime_type, timestamp=now())
+        ]))
+
+    def global_error(self, message=None, trace=None, status=ErrorStatus.BROKEN):
+        plugin_manager.hook.report_globals(globals_item=Globals(errors=[
+            GlobalError(status=status, message=message, trace=trace, timestamp=now())
+        ]))
+
+    def __resolve_attachment_filename_and_type(self, uuid, attachment_type=None, extension=None):
+        mime_type = attachment_type
+        extension = extension if extension else "attach"
+
+        if type(attachment_type) is AttachmentType:
+            extension = attachment_type.extension
+            mime_type = attachment_type.mime_type
+
+        file_name = ATTACHMENT_PATTERN.format(prefix=uuid, ext=extension)
+        return file_name, mime_type
diff --git a/allure-python-commons/src/allure_commons/logger.py b/allure-python-commons/src/allure_commons/logger.py
index 55f956f2..85975493 100644
--- a/allure-python-commons/src/allure_commons/logger.py
+++ b/allure-python-commons/src/allure_commons/logger.py
@@ -22,9 +22,15 @@ def _report_item(self, item):
         indent = INDENT if os.environ.get("ALLURE_INDENT_OUTPUT") else None
         filename = item.file_pattern.format(prefix=uuid.uuid4())
         data = asdict(item, filter=lambda _, v: v or v is False)
-        with io.open(self._report_dir / filename, 'w', encoding='utf8') as json_file:
+
+        tmp_filepath = self._report_dir / f"{filename}.tmp"
+        final_filepath = self._report_dir / filename
+
+        with io.open(tmp_filepath, "w", encoding="utf8") as json_file:
             json.dump(data, json_file, indent=indent, ensure_ascii=False)
 
+        os.replace(tmp_filepath, final_filepath)
+
     @hookimpl
     def report_result(self, result):
         self._report_item(result)
@@ -35,17 +41,25 @@ def report_container(self, container):
 
     @hookimpl
     def report_attached_file(self, source, file_name):
-        destination = self._report_dir / file_name
-        shutil.copy2(source, destination)
+        tmp_destination = self._report_dir / f"{file_name}.tmp"
+        final_destination = self._report_dir / file_name
+        shutil.copy2(source, tmp_destination)
+        os.replace(tmp_destination, final_destination)
 
     @hookimpl
     def report_attached_data(self, body, file_name):
-        destination = self._report_dir / file_name
-        with open(destination, 'wb') as attached_file:
+        tmp_destination = self._report_dir / f"{file_name}.tmp"
+        final_destination = self._report_dir / file_name
+        with open(tmp_destination, "wb") as attached_file:
             if isinstance(body, str):
-                attached_file.write(body.encode('utf-8'))
+                attached_file.write(body.encode("utf-8"))
             else:
                 attached_file.write(body)
+        os.replace(tmp_destination, final_destination)
+
+    @hookimpl
+    def report_globals(self, globals_item):
+        self._report_item(globals_item)
 
 
 class AllureMemoryLogger:
@@ -54,6 +68,7 @@ def __init__(self):
         self.test_cases = []
         self.test_containers = []
         self.attachments = {}
+        self.globals = []
 
     @hookimpl
     def report_result(self, result):
@@ -72,3 +87,8 @@ def report_attached_file(self, source, file_name):
     @hookimpl
     def report_attached_data(self, body, file_name):
         self.attachments[file_name] = body
+
+    @hookimpl
+    def report_globals(self, globals_item):
+        data = asdict(globals_item, filter=lambda _, v: v or v is False)
+        self.globals.append(data)
diff --git a/allure-python-commons/src/allure_commons/mapping.py b/allure-python-commons/src/allure_commons/mapping.py
index 737d3390..0cd099f0 100644
--- a/allure-python-commons/src/allure_commons/mapping.py
+++ b/allure-python-commons/src/allure_commons/mapping.py
@@ -20,7 +20,7 @@ def allure_tag_sep(tag):
 
 
 def __is(kind, t):
-    return kind in [v for k, v in t.__dict__.items() if not k.startswith('__')]
+    return kind in [v for k, v in t.__dict__.items() if not k.startswith("__")]
 
 
 def parse_tag(tag, issue_pattern=None, link_pattern=None):
@@ -51,7 +51,7 @@ def parse_tag(tag, issue_pattern=None, link_pattern=None):
     """
     sep = allure_tag_sep(tag)
     schema, value = islice(chain(tag.split(sep, 1), [None]), 2)
-    prefix, kind, name = islice(chain(schema.split('.'), [None], [None]), 3)
+    prefix, kind, name = islice(chain(schema.split("."), [None], [None]), 3)
 
     if tag in [severity for severity in Severity]:
         return Label(name=LabelType.SEVERITY, value=tag)
diff --git a/allure-python-commons/src/allure_commons/model2.py b/allure-python-commons/src/allure_commons/model2.py
index ccaf4459..d2a307cc 100644
--- a/allure-python-commons/src/allure_commons/model2.py
+++ b/allure-python-commons/src/allure_commons/model2.py
@@ -1,10 +1,12 @@
 from attr import attrs, attrib
 from attr import Factory
+from allure_commons.types import ErrorStatus
 
 
 TEST_GROUP_PATTERN = "{prefix}-container.json"
 TEST_CASE_PATTERN = "{prefix}-result.json"
-ATTACHMENT_PATTERN = '{prefix}-attachment.{ext}'
+ATTACHMENT_PATTERN = "{prefix}-attachment.{ext}"
+GLOBALS_PATTERN = "{prefix}-globals.json"
 INDENT = 4
 
 
@@ -49,11 +51,12 @@ class TestResult(ExecutableItem):
     fullName = attrib(default=None)
     labels = attrib(default=Factory(list))
     links = attrib(default=Factory(list))
+    titlePath = attrib(default=Factory(list))
 
 
 @attrs
 class TestStepResult(ExecutableItem):
-    id = attrib(default=None)  # noqa: A003
+    id = attrib(default=None)
 
 
 @attrs
@@ -82,7 +85,7 @@ class Label:
 
 @attrs
 class Link:
-    type = attrib(default=None)  # noqa: A003
+    type = attrib(default=None)
     url = attrib(default=None)
     name = attrib(default=None)
 
@@ -99,12 +102,31 @@ class StatusDetails:
 class Attachment:
     name = attrib(default=None)
     source = attrib(default=None)
-    type = attrib(default=None)  # noqa: A003
+    type = attrib(default=None)
+
+
+@attrs
+class GlobalAttachment(Attachment):
+    timestamp = attrib(default=None)
+
+
+@attrs
+class GlobalError(StatusDetails):
+    status = attrib(default=ErrorStatus.BROKEN)
+    timestamp = attrib(default=None)
+
+
+@attrs
+class Globals:
+    file_pattern = GLOBALS_PATTERN
+
+    attachments = attrib(default=Factory(list))
+    errors = attrib(default=Factory(list))
 
 
 class Status:
-    FAILED = 'failed'
-    BROKEN = 'broken'
-    PASSED = 'passed'
-    SKIPPED = 'skipped'
-    UNKNOWN = 'unknown'
+    FAILED = "failed"
+    BROKEN = "broken"
+    PASSED = "passed"
+    SKIPPED = "skipped"
+    UNKNOWN = "unknown"
diff --git a/allure-python-commons/src/allure_commons/reporter.py b/allure-python-commons/src/allure_commons/reporter.py
index 2e1f4a89..4cb011c2 100644
--- a/allure-python-commons/src/allure_commons/reporter.py
+++ b/allure-python-commons/src/allure_commons/reporter.py
@@ -5,6 +5,8 @@
 from allure_commons.model2 import ExecutableItem
 from allure_commons.model2 import TestResult
 from allure_commons.model2 import Attachment, ATTACHMENT_PATTERN
+from allure_commons.model2 import GlobalAttachment, GlobalError, Globals
+from allure_commons.types import ErrorStatus
 from allure_commons.utils import now
 from allure_commons._core import plugin_manager
 
@@ -140,14 +142,7 @@ def stop_step(self, uuid, **kwargs):
             self._items.pop(uuid)
 
     def _attach(self, uuid, name=None, attachment_type=None, extension=None, parent_uuid=None):
-        mime_type = attachment_type
-        extension = extension if extension else 'attach'
-
-        if type(attachment_type) is AttachmentType:
-            extension = attachment_type.extension
-            mime_type = attachment_type.mime_type
-
-        file_name = ATTACHMENT_PATTERN.format(prefix=uuid, ext=extension)
+        file_name, mime_type = self.__resolve_attachment_filename_and_type(uuid, attachment_type, extension)
         attachment = Attachment(source=file_name, name=name, type=mime_type)
         last_uuid = parent_uuid if parent_uuid else self._last_executable()
         self._items[last_uuid].attachments.append(attachment)
@@ -163,3 +158,33 @@ def attach_data(self, uuid, body, name=None, attachment_type=None, extension=Non
         file_name = self._attach(uuid, name=name, attachment_type=attachment_type,
                                  extension=extension, parent_uuid=parent_uuid)
         plugin_manager.hook.report_attached_data(body=body, file_name=file_name)
+
+    def global_attach_file(self, uuid, source, name=None, attachment_type=None, extension=None):
+        file_name, mime_type = self.__resolve_attachment_filename_and_type(uuid, attachment_type, extension)
+        plugin_manager.hook.report_attached_file(source=source, file_name=file_name)
+        plugin_manager.hook.report_globals(globals_item=Globals(attachments=[
+            GlobalAttachment(source=file_name, name=name, type=mime_type, timestamp=now())
+        ]))
+
+    def global_attach_data(self, uuid, body, name=None, attachment_type=None, extension=None):
+        file_name, mime_type = self.__resolve_attachment_filename_and_type(uuid, attachment_type, extension)
+        plugin_manager.hook.report_attached_data(body=body, file_name=file_name)
+        plugin_manager.hook.report_globals(globals_item=Globals(attachments=[
+            GlobalAttachment(source=file_name, name=name, type=mime_type, timestamp=now())
+        ]))
+
+    def global_error(self, message=None, trace=None, status=ErrorStatus.BROKEN):
+        plugin_manager.hook.report_globals(globals_item=Globals(errors=[
+            GlobalError(status=status, message=message, trace=trace, timestamp=now())
+        ]))
+
+    def __resolve_attachment_filename_and_type(self, uuid, attachment_type=None, extension=None):
+        mime_type = attachment_type
+        extension = extension if extension else "attach"
+
+        if type(attachment_type) is AttachmentType:
+            extension = attachment_type.extension
+            mime_type = attachment_type.mime_type
+
+        file_name = ATTACHMENT_PATTERN.format(prefix=uuid, ext=extension)
+        return file_name, mime_type
diff --git a/allure-python-commons/src/allure_commons/types.py b/allure-python-commons/src/allure_commons/types.py
index e631e427..89d70c99 100644
--- a/allure-python-commons/src/allure_commons/types.py
+++ b/allure-python-commons/src/allure_commons/types.py
@@ -1,37 +1,37 @@
 from enum import Enum
 
-ALLURE_UNIQUE_LABELS = ['severity', 'thread', 'host']
+ALLURE_UNIQUE_LABELS = ["severity", "thread", "host"]
 
 
 class Severity(str, Enum):
-    BLOCKER = 'blocker'
-    CRITICAL = 'critical'
-    NORMAL = 'normal'
-    MINOR = 'minor'
-    TRIVIAL = 'trivial'
+    BLOCKER = "blocker"
+    CRITICAL = "critical"
+    NORMAL = "normal"
+    MINOR = "minor"
+    TRIVIAL = "trivial"
 
 
 class LinkType:
-    LINK = 'link'
-    ISSUE = 'issue'
-    TEST_CASE = 'tms'
+    LINK = "link"
+    ISSUE = "issue"
+    TEST_CASE = "tms"
 
 
 class LabelType(str):
-    EPIC = 'epic'
-    FEATURE = 'feature'
-    STORY = 'story'
-    PARENT_SUITE = 'parentSuite'
-    SUITE = 'suite'
-    SUB_SUITE = 'subSuite'
-    SEVERITY = 'severity'
-    THREAD = 'thread'
-    HOST = 'host'
-    TAG = 'tag'
-    ID = 'as_id'
-    FRAMEWORK = 'framework'
-    LANGUAGE = 'language'
-    MANUAL = 'ALLURE_MANUAL'
+    EPIC = "epic"
+    FEATURE = "feature"
+    STORY = "story"
+    PARENT_SUITE = "parentSuite"
+    SUITE = "suite"
+    SUB_SUITE = "subSuite"
+    SEVERITY = "severity"
+    THREAD = "thread"
+    HOST = "host"
+    TAG = "tag"
+    ID = "as_id"
+    FRAMEWORK = "framework"
+    LANGUAGE = "language"
+    MANUAL = "ALLURE_MANUAL"
 
 
 class AttachmentType(Enum):
@@ -46,10 +46,12 @@ def __init__(self, mime_type, extension):
     URI_LIST = ("text/uri-list", "uri")
 
     HTML = ("text/html", "html")
+    MARKDOWN = ("text/markdown", "md")
     XML = ("application/xml", "xml")
     JSON = ("application/json", "json")
     YAML = ("application/yaml", "yaml")
     PCAP = ("application/vnd.tcpdump.pcap", "pcap")
+    ZIP = ("application/zip", "zip")
 
     PNG = ("image/png", "png")
     JPG = ("image/jpg", "jpg")
@@ -66,6 +68,11 @@ def __init__(self, mime_type, extension):
 
 
 class ParameterMode(Enum):
-    HIDDEN = 'hidden'
-    MASKED = 'masked'
+    HIDDEN = "hidden"
+    MASKED = "masked"
     DEFAULT = None
+
+
+class ErrorStatus(str, Enum):
+    BROKEN = "broken"
+    FAILED = "failed"
diff --git a/allure-python-commons/src/allure_commons/utils.py b/allure-python-commons/src/allure_commons/utils.py
index 5ba0d377..c50cb7ec 100644
--- a/allure-python-commons/src/allure_commons/utils.py
+++ b/allure-python-commons/src/allure_commons/utils.py
@@ -21,7 +21,7 @@ def md5(*args):
         if not isinstance(arg, bytes):
             if not isinstance(arg, str):
                 arg = repr(arg)
-            arg = arg.encode('utf-8')
+            arg = arg.encode("utf-8")
         m.update(arg)
     return m.hexdigest()
 
@@ -37,11 +37,11 @@ def now():
 def platform_label():
     major_version, *_ = platform.python_version_tuple()
     implementation = platform.python_implementation().lower()
-    return f'{implementation}{major_version}'
+    return f"{implementation}{major_version}"
 
 
 def thread_tag():
-    return '{0}-{1}'.format(os.getpid(), threading.current_thread().name)
+    return "{0}-{1}".format(os.getpid(), threading.current_thread().name)
 
 
 def host_tag():
@@ -241,7 +241,7 @@ def func_parameters(func, *args, **kwargs):
         varargs = args[len(arg_spec.args):]
         parameters.update({arg_spec.varargs: varargs} if varargs else {})
 
-    if arg_spec.args and arg_spec.args[0] in ['cls', 'self']:
+    if arg_spec.args and arg_spec.args[0] in ["cls", "self"]:
         args_dict.pop(arg_spec.args[0], None)
 
     if kwargs:
@@ -269,7 +269,7 @@ def func_parameters(func, *args, **kwargs):
 
 
 def format_traceback(exc_traceback):
-    return ''.join(traceback.format_tb(exc_traceback)) if exc_traceback else None
+    return "".join(traceback.format_tb(exc_traceback)) if exc_traceback else None
 
 
 def format_exception(etype, value):
@@ -320,7 +320,7 @@ def format_exception(etype, value):
     ...     format_exception(etype, e) # doctest: +ELLIPSIS
     "AssertionError: \\nExpected:...but:..."
     """
-    return '\n'.join(format_exception_only(etype, value)) if etype or value else None
+    return "\n".join(format_exception_only(etype, value)) if etype or value else None
 
 
 def get_testplan():
@@ -328,7 +328,7 @@ def get_testplan():
     file_path = os.environ.get("ALLURE_TESTPLAN_PATH")
 
     if file_path and os.path.exists(file_path):
-        with open(file_path, 'r') as plan_file:
+        with open(file_path, "r") as plan_file:
             plan = json.load(plan_file)
             planned_tests = plan.get("tests", [])
 
diff --git a/allure-robotframework/pyproject.toml b/allure-robotframework/pyproject.toml
index 0ee96703..2d6844e1 100644
--- a/allure-robotframework/pyproject.toml
+++ b/allure-robotframework/pyproject.toml
@@ -1,5 +1,5 @@
 [tool.poe.tasks]
-linter = "flake8 ./src"
+linter = "ruff check"
 
 [tool.poe.tasks.tests]
 shell = "python -m doctest ./src/listener/utils.py && pytest ../tests/allure_robotframework"
diff --git a/allure-robotframework/setup.py b/allure-robotframework/setup.py
index 8b194c29..9cb42fe7 100644
--- a/allure-robotframework/setup.py
+++ b/allure-robotframework/setup.py
@@ -4,25 +4,25 @@
 PACKAGE = "allure-robotframework"
 
 classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Framework :: Robot Framework',
-    'Framework :: Robot Framework :: Tool',
-    'Intended Audience :: Developers',
-    'License :: OSI Approved :: Apache Software License',
-    'Topic :: Software Development :: Quality Assurance',
-    'Topic :: Software Development :: Testing',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'Programming Language :: Python :: 3.13',
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Tool",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 setup_requires = [
-    "setuptools_scm"
+    "setuptools_scm<10"
 ]
 
 install_requires = [
@@ -41,7 +41,7 @@ def get_readme(fname):
     return open(os.path.join(os.path.dirname(__file__), fname)).read()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     setup(
         name=PACKAGE,
         use_scm_version=prepare_version,
@@ -50,9 +50,9 @@ def get_readme(fname):
         install_requires=install_requires,
         setup_requires=setup_requires,
         keywords="allure reporting robotframework",
-        packages=['allure_robotframework', 'AllureLibrary'],
-        package_dir={"allure_robotframework": "src/listener", 'AllureLibrary': 'src/library'},
-        py_modules=['allure_robotframework'],
+        packages=["allure_robotframework", "AllureLibrary"],
+        package_dir={"allure_robotframework": "src/listener", "AllureLibrary": "src/library"},
+        py_modules=["allure_robotframework"],
         url="https://allurereport.org/",
         project_urls={
             "Source": "https://github.com/allure-framework/allure-python",
diff --git a/allure-robotframework/src/library/__init__.py b/allure-robotframework/src/library/__init__.py
index 0786652e..d21bce6b 100644
--- a/allure-robotframework/src/library/__init__.py
+++ b/allure-robotframework/src/library/__init__.py
@@ -1,3 +1,3 @@
-from .allure_library import attach, attach_file
+from .allure_library import attach, attach_file, global_attach, global_attach_file, global_error
 
-__all__ = ['attach', 'attach_file']
+__all__ = ["attach", "attach_file", "global_attach", "global_attach_file", "global_error"]
diff --git a/allure-robotframework/src/library/allure_library.py b/allure-robotframework/src/library/allure_library.py
index a7dc93e5..bb731341 100644
--- a/allure-robotframework/src/library/allure_library.py
+++ b/allure-robotframework/src/library/allure_library.py
@@ -1,7 +1,7 @@
 import allure
 
 
-__all__ = ['attach', 'attach_file']
+__all__ = ["attach", "attach_file", "global_attach", "global_attach_file", "global_error"]
 
 
 def _attachment_type(name):
@@ -17,3 +17,15 @@ def attach(data, name=None, attachment_type=None, extension=None):
 
 def attach_file(source, name=None, attachment_type=None, extension=None):
     allure.attach.file(source, name=name, attachment_type=_attachment_type(attachment_type), extension=extension)
+
+
+def global_attach(data, name=None, attachment_type=None, extension=None):
+    allure.global_attach(data, name=name, attachment_type=_attachment_type(attachment_type), extension=extension)
+
+
+def global_attach_file(source, name=None, attachment_type=None, extension=None):
+    allure.global_attach.file(source, name=name, attachment_type=_attachment_type(attachment_type), extension=extension)
+
+
+def global_error(message, trace=None, *, status = allure.error_status.BROKEN):
+    allure.global_error(message, trace=trace, status=status)
diff --git a/allure-robotframework/src/listener/__init__.py b/allure-robotframework/src/listener/__init__.py
index d2640a4e..92740385 100644
--- a/allure-robotframework/src/listener/__init__.py
+++ b/allure-robotframework/src/listener/__init__.py
@@ -1,4 +1,4 @@
 from allure_robotframework.robot_listener import allure_robotframework
 from allure_robotframework.allure_testplan import allure_testplan as testplan
 
-__all__ = ['allure_robotframework', "testplan"]
+__all__ = ["allure_robotframework", "testplan"]
diff --git a/allure-robotframework/src/listener/allure_listener.py b/allure-robotframework/src/listener/allure_listener.py
index 2a4d3a80..eb55e5f7 100644
--- a/allure-robotframework/src/listener/allure_listener.py
+++ b/allure-robotframework/src/listener/allure_listener.py
@@ -39,8 +39,8 @@ def get_status_details(exc_type, exception, exc_traceback):
 
 
 def pool_id():
-    pabot_pool_id = BuiltIn().get_variable_value('${PABOTEXECUTIONPOOLID}')
-    pabot_caller_id = BuiltIn().get_variable_value('${CALLER_ID}')
+    pabot_pool_id = BuiltIn().get_variable_value("${PABOTEXECUTIONPOOLID}")
+    pabot_caller_id = BuiltIn().get_variable_value("${CALLER_ID}")
     return f"{pabot_pool_id}-{pabot_caller_id}" if all([
         pabot_pool_id,
         pabot_caller_id
@@ -52,9 +52,9 @@ def get_message_time(timestamp):
     return int(s_time.timestamp() * 1000)
 
 
-LOG_MESSAGE_FORMAT = '<p><b>[{level}]</b>&nbsp;{message}</p>'
+LOG_MESSAGE_FORMAT = "<p><b>[{level}]</b>&nbsp;{message}</p>"
 FAIL_MESSAGE_FORMAT = '<p style="color: red"><b>[{level}]</b>&nbsp;{message}</p>'
-MAX_STEP_MESSAGE_COUNT = int(os.getenv('ALLURE_MAX_STEP_MESSAGE_COUNT', 0))
+MAX_STEP_MESSAGE_COUNT = int(os.getenv("ALLURE_MAX_STEP_MESSAGE_COUNT", 0))
 
 
 class AllureListener:
@@ -70,8 +70,8 @@ def start_suite_container(self, name, attributes):
             pass
 
     def stop_suite_container(self, name, attributes):
-        suite_status = get_allure_status(attributes.get('status'))
-        suite_message = attributes.get('message')
+        suite_status = get_allure_status(attributes.get("status"))
+        suite_message = attributes.get("message")
 
         with self.lifecycle.update_container() as container:
             for uuid in container.children:
@@ -89,8 +89,8 @@ def start_test_container(self, name, attributes):
             pass
 
     def stop_test_container(self, name, attributes):
-        suite_status = get_allure_status(attributes.get('status'))
-        suite_message = attributes.get('message')
+        suite_status = get_allure_status(attributes.get("status"))
+        suite_message = attributes.get("message")
 
         with self.lifecycle.schedule_test_case() as test_result:
             if test_result.status == Status.PASSED and suite_message:
@@ -106,7 +106,7 @@ def start_before_fixture(self, name):
             fixture.name = name
 
     def stop_before_fixture(self, attributes, messages):
-        status = attributes.get('status')
+        status = attributes.get("status")
         self._report_messages(status, messages)
         with self.lifecycle.update_before_fixture() as fixture:
             fixture.status = get_allure_status(status)
@@ -118,7 +118,7 @@ def start_after_fixture(self, name):
             fixture.name = name
 
     def stop_after_fixture(self, attributes, messages):
-        status = attributes.get('status')
+        status = attributes.get("status")
         self._report_messages(status, messages)
         with self.lifecycle.update_after_fixture() as fixture:
             fixture.status = get_allure_status(status)
@@ -128,36 +128,38 @@ def stop_after_fixture(self, attributes, messages):
     def start_test(self, name, attributes):
         uuid = uuid4()
         with self.lifecycle.schedule_test_case(uuid=uuid) as test_result:
-            long_name = attributes.get('longname')
+            long_name = attributes.get("longname")
             test_result.name = name
             test_result.fullName = long_name
-            test_result.historyId = md5(long_name)
+            test_result.titlePath = attributes.get("titlepath", [])
+            test_result.testCaseId = md5(long_name)
+            test_result.historyId = test_result.testCaseId
             test_result.start = now()
 
         for container in self.lifecycle.containers():
             container.children.append(uuid)
 
     def stop_test(self, _, attributes, messages):
-        self._report_messages(attributes.get('status'), messages)
+        self._report_messages(attributes.get("status"), messages)
 
-        if 'skipped' in [tag.lower() for tag in attributes['tags']]:
-            attributes['status'] = RobotStatus.SKIPPED
+        if "skipped" in [tag.lower() for tag in attributes["tags"]]:
+            attributes["status"] = RobotStatus.SKIPPED
 
         with self.lifecycle.update_test_case() as test_result:
             test_result.stop = now()
-            test_result.description = attributes.get('doc')
-            test_result.status = get_allure_status(attributes.get('status'))
-            test_result.labels.extend(get_allure_suites(attributes.get('longname')))
-            test_result.labels.append(Label(name=LabelType.FRAMEWORK, value='robotframework'))
+            test_result.description = attributes.get("doc")
+            test_result.status = get_allure_status(attributes.get("status"))
+            test_result.labels.extend(get_allure_suites(attributes.get("longname")))
+            test_result.labels.append(Label(name=LabelType.FRAMEWORK, value="robotframework"))
             test_result.labels.append(Label(name=LabelType.LANGUAGE, value=self._platform))
             test_result.labels.append(Label(name=LabelType.HOST, value=self._host))
             test_result.labels.append(Label(name=LabelType.THREAD, value=pool_id()))
-            tags = attributes.get('tags', ())
+            tags = attributes.get("tags", ())
             test_result.labels.extend(allure_labels(tags))
-            test_result.statusDetails = StatusDetails(message=attributes.get('message'),
+            test_result.statusDetails = StatusDetails(message=attributes.get("message"),
                                                       trace=self._current_tb)
 
-            if attributes.get('critical') == 'yes':
+            if attributes.get("critical") == "yes":
                 test_result.labels.append(Label(name=LabelType.SEVERITY, value=Severity.CRITICAL))
 
             for link_type in (LinkType.ISSUE, LinkType.TEST_CASE, LinkType.LINK):
@@ -170,11 +172,11 @@ def start_keyword(self, name):
             step.name = name
 
     def stop_keyword(self, attributes, messages):
-        status = attributes.get('status')
+        status = attributes.get("status")
         self._report_messages(status, messages)
         with self.lifecycle.update_step() as step:
             step.status = get_allure_status(status)
-            step.parameters = get_allure_parameters(attributes.get('args'))
+            step.parameters = get_allure_parameters(attributes.get("args"))
             step.statusDetails = StatusDetails(message=self._current_msg, trace=self._current_tb)
         self.lifecycle.stop_step()
 
@@ -186,8 +188,8 @@ def _report_messages(self, status, messages):
             self._current_tb, self._current_msg = None, None
 
         for message, next_message in zip_longest(messages, messages[1:]):
-            name = message.get('message')
-            level = message.get('level')
+            name = message.get("message")
+            level = message.get("level")
             message_format = FAIL_MESSAGE_FORMAT if level in RobotLogLevel.CRITICAL_LEVELS else LOG_MESSAGE_FORMAT
 
             if level == RobotLogLevel.FAIL:
@@ -195,7 +197,7 @@ def _report_messages(self, status, messages):
                 self._current_tb = next_message.get("message") if has_trace and next_message else self._current_tb
 
             if len(messages) > MAX_STEP_MESSAGE_COUNT:
-                attachment += message_format.format(level=level, message=name.replace('\n', '<br>'))
+                attachment += message_format.format(level=level, message=name.replace("\n", "<br>"))
             else:
                 with self.lifecycle.start_step() as step:
                     step.name = name
@@ -204,7 +206,7 @@ def _report_messages(self, status, messages):
                 self.lifecycle.stop_step()
 
         if attachment:
-            self.lifecycle.attach_data(uuid=uuid4(), body=attachment, name='Keyword Log',
+            self.lifecycle.attach_data(uuid=uuid4(), body=attachment, name="Keyword Log",
                                        attachment_type=AttachmentType.HTML)
 
     @allure_commons.hookimpl
@@ -237,6 +239,30 @@ def attach_data(self, body, name, attachment_type, extension):
     def attach_file(self, source, name, attachment_type, extension):
         self.lifecycle.attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)
 
+    @allure_commons.hookimpl
+    def global_attach_data(self, body, name, attachment_type, extension):
+        self.lifecycle.global_attach_data(
+            uuid4(),
+            body,
+            name=name,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+
+    @allure_commons.hookimpl
+    def global_attach_file(self, source, name, attachment_type, extension):
+        self.lifecycle.global_attach_file(
+            uuid4(),
+            source,
+            name=name,
+            attachment_type=attachment_type,
+            extension=extension,
+        )
+
+    @allure_commons.hookimpl
+    def global_error(self, message, trace, status):
+        self.lifecycle.global_error(message=message, trace=trace, status=status)
+
     @allure_commons.hookimpl
     def start_step(self, uuid, title, params):
         with self.lifecycle.start_step() as step:
diff --git a/allure-robotframework/src/listener/robot_listener.py b/allure-robotframework/src/listener/robot_listener.py
index 9dab210e..acc0624c 100644
--- a/allure-robotframework/src/listener/robot_listener.py
+++ b/allure-robotframework/src/listener/robot_listener.py
@@ -7,7 +7,7 @@
 from allure_robotframework.types import RobotKeywordType
 
 
-DEFAULT_OUTPUT_PATH = os.path.join('output', 'allure')
+DEFAULT_OUTPUT_PATH = os.path.join("output", "allure")
 
 
 # noinspection PyPep8Naming
@@ -16,6 +16,7 @@ class allure_robotframework:
 
     def __init__(self, logger_path=DEFAULT_OUTPUT_PATH):
         self.messages = Messages()
+        self.title_path = []
 
         self.logger = AllureFileLogger(logger_path)
         self.lifecycle = AllureLifecycle()
@@ -25,17 +26,19 @@ def __init__(self, logger_path=DEFAULT_OUTPUT_PATH):
         allure_commons.plugin_manager.register(self.listener)
 
     def start_suite(self, name, attributes):
+        self.title_path.append(name)
         self.messages.start_context()
         self.listener.start_suite_container(name, attributes)
 
     def end_suite(self, name, attributes):
         self.messages.stop_context()
         self.listener.stop_suite_container(name, attributes)
+        self.title_path.pop()
 
     def start_test(self, name, attributes):
         self.messages.start_context()
         self.listener.start_test_container(name, attributes)
-        self.listener.start_test(name, attributes)
+        self.listener.start_test(name, {**attributes, "titlepath": self.title_path})
 
     def end_test(self, name, attributes):
         messages = self.messages.stop_context()
@@ -44,9 +47,9 @@ def end_test(self, name, attributes):
 
     def start_keyword(self, name, attributes):
         self.messages.start_context()
-        keyword_type = attributes.get('type')
+        keyword_type = attributes.get("type")
         # Todo fix value assign
-        keyword_name = '{} = {}'.format(attributes.get('assign')[0], name) if attributes.get('assign') else name
+        keyword_name = "{} = {}".format(attributes.get("assign")[0], name) if attributes.get("assign") else name
         if keyword_type.upper() == RobotKeywordType.SETUP:
             self.listener.start_before_fixture(keyword_name)
         elif keyword_type.upper() == RobotKeywordType.TEARDOWN:
@@ -56,7 +59,7 @@ def start_keyword(self, name, attributes):
 
     def end_keyword(self, _, attributes):
         messages = self.messages.stop_context()
-        keyword_type = attributes.get('type')
+        keyword_type = attributes.get("type")
         if keyword_type.upper() == RobotKeywordType.SETUP:
             self.listener.stop_before_fixture(attributes, messages)
         elif keyword_type.upper() == RobotKeywordType.TEARDOWN:
diff --git a/allure-robotframework/src/listener/types.py b/allure-robotframework/src/listener/types.py
index 84dfb794..db12f4db 100644
--- a/allure-robotframework/src/listener/types.py
+++ b/allure-robotframework/src/listener/types.py
@@ -1,26 +1,26 @@
 class RobotStatus:
-    FAILED = 'FAIL'
-    PASSED = 'PASS'
-    SKIPPED = 'SKIP'
-    NOT_RUN = 'NOT RUN'
-    NOT_SET = 'NOT SET'
+    FAILED = "FAIL"
+    PASSED = "PASS"
+    SKIPPED = "SKIP"
+    NOT_RUN = "NOT RUN"
+    NOT_SET = "NOT SET"
 
 
 class RobotKeywordType:
-    SETUP = 'SETUP'
-    TEARDOWN = 'TEARDOWN'
-    KEYWORD = 'KEYWORD'
-    LOOP = 'FOR'
-    LOOP_ITEM = 'FOR ITEM'
+    SETUP = "SETUP"
+    TEARDOWN = "TEARDOWN"
+    KEYWORD = "KEYWORD"
+    LOOP = "FOR"
+    LOOP_ITEM = "FOR ITEM"
     FIXTURES = [SETUP, TEARDOWN]
 
 
 class RobotLogLevel:
-    FAIL = 'FAIL'
-    ERROR = 'ERROR'
-    WARNING = 'WARN'
-    INFORMATION = 'INFO'
-    DEBUG = 'DEBUG'
-    TRACE = 'TRACE'
+    FAIL = "FAIL"
+    ERROR = "ERROR"
+    WARNING = "WARN"
+    INFORMATION = "INFO"
+    DEBUG = "DEBUG"
+    TRACE = "TRACE"
 
     CRITICAL_LEVELS = [FAIL, ERROR]
diff --git a/allure-robotframework/src/listener/utils.py b/allure-robotframework/src/listener/utils.py
index 8b308d81..b587849e 100644
--- a/allure-robotframework/src/listener/utils.py
+++ b/allure-robotframework/src/listener/utils.py
@@ -35,12 +35,12 @@ def get_allure_suites(longname):
     Label(name='subSuite', value='Suite3')]
     """
     labels = []
-    suites = longname.split('.')
+    suites = longname.split(".")
     if len(suites) > 3:
         labels.append(Label(LabelType.PARENT_SUITE, suites.pop(0)))
     labels.append(Label(LabelType.SUITE, suites.pop(0)))
     if len(suites) > 1:
-        labels.append(Label(LabelType.SUB_SUITE, '.'.join(suites[:-1])))
+        labels.append(Label(LabelType.SUB_SUITE, ".".join(suites[:-1])))
     return labels
 
 
@@ -60,7 +60,7 @@ def allure_labels(tags):
 
 
 def allure_links(attributes, prefix):
-    tags = attributes.get('tags', ())
+    tags = attributes.get("tags", ())
 
     general_syntax_links = [
         link for link in get_items_of_type_from_tags(
@@ -79,15 +79,15 @@ def allure_links(attributes, prefix):
 
 
 def _parse_link(link):
-    lnk_val = link.split(':', 1)[1] or 'unknown'
-    lnk_label = search(r'^\[(.+)\]', lnk_val)
+    lnk_val = link.split(":", 1)[1] or "unknown"
+    lnk_label = search(r"^\[(.+)\]", lnk_val)
     if lnk_label:
         lnk_val = lnk_val[lnk_label.end():]
         lnk_label = lnk_label.group(1)
     else:
         lnk_label = lnk_val
 
-    return {'name': lnk_label, 'value': lnk_val}
+    return {"name": lnk_label, "value": lnk_val}
 
 
 def _create_link_from_tag(prefix, link_tag):
diff --git a/pyproject.toml b/pyproject.toml
index f52572e9..b43cc5cb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,5 @@
 [tool.poe.tasks]
-linter = "flake8 ./allure-*/src ./tests"
+linter = "ruff check"
 allure-generate = "allure generate --clean --output ./.allure-report ./.allure-results"
 allure-open = "allure open ./.allure-report"
 
@@ -19,3 +19,19 @@ addopts = [
     "-p", "no:allure_pytest",
     "-p", "no:allure_pytest_bdd"
 ]
+
+[tool.ruff]
+extend-exclude = [
+    "tests/allure_behave/acceptance/**/test-data/**",
+    "tests/allure_behave/acceptance/behave_support/background/background_steps.py",
+]
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "A",  # flake8-builtins
+    "E",  # pycodestyle errors
+    "F",  # pyflakes
+    "Q",  # flake8-quotes
+    "W",  # pycodestyle warnings
+]
diff --git a/requirements/linting.txt b/requirements/linting.txt
index fc08386d..ebd9e468 100644
--- a/requirements/linting.txt
+++ b/requirements/linting.txt
@@ -1,3 +1,2 @@
 -r ./core.txt
-flake8
-flake8-builtins
+ruff
diff --git a/tests/allure_behave/acceptance/allure_api/globals/__init__.py b/tests/allure_behave/acceptance/allure_api/globals/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_behave/acceptance/allure_api/globals/globals_test.py b/tests/allure_behave/acceptance/allure_api/globals/globals_test.py
new file mode 100644
index 00000000..22bfb2d4
--- /dev/null
+++ b/tests/allure_behave/acceptance/allure_api/globals/globals_test.py
@@ -0,0 +1,89 @@
+import textwrap
+from tests.allure_behave.behave_runner import AllureBehaveRunner as Runner
+from hamcrest import assert_that, equal_to, has_item, has_length
+from allure_commons_test.result import has_global_attachment_with_content
+from allure_commons_test.result import has_global_error
+from allure_commons_test.result import with_message_contains, with_status
+
+
+def test_global_attachment_and_error_hooks(behave_runner: Runner):
+    behave_runner.run_behave(
+        feature_literals=[
+            """
+            Feature: Global attachments and errors
+                Scenario: Global hooks
+                    Given noop
+            """
+        ],
+        step_literals=["given('noop')(lambda c: None)"],
+        environment_literal=textwrap.dedent(
+            """
+            import allure
+
+
+            def before_all(context):
+                allure.global_attach("behave global attachment", name="behave global")
+
+
+            def after_all(context):
+                allure.global_error("behave global error")
+            """
+        ),
+    )
+
+    assert_that(
+        behave_runner.allure_results.globals,
+        has_length(2),
+    )
+
+    assert_that(
+        behave_runner.allure_results.globals,
+        has_item(
+            has_global_attachment_with_content(
+                behave_runner.allure_results.attachments,
+                equal_to("behave global attachment"),
+                name="behave global"
+            )
+        )
+    )
+    assert_that(
+        behave_runner.allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("behave global error"),
+                with_status("broken"),
+            )
+        )
+    )
+
+
+def test_global_error_support_explicit_status(behave_runner: Runner):
+    behave_runner.run_behave(
+        feature_literals=[
+            """
+            Feature: Failed global error
+                Scenario: Global error
+                    Given noop
+            """
+        ],
+        step_literals=["given('noop')(lambda c: None)"],
+        environment_literal=textwrap.dedent(
+            """
+            import allure
+
+
+            def after_all(context):
+                allure.global_error("behave global error", status=allure.error_status.FAILED)
+            """
+        ),
+    )
+
+    assert_that(
+        behave_runner.allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("behave global error"),
+                with_status("failed"),
+            )
+        )
+    )
diff --git a/tests/allure_behave/acceptance/behave_support/scenarios/scenario_test.py b/tests/allure_behave/acceptance/behave_support/scenarios/scenario_test.py
index 28b3f696..bb2cbfb3 100644
--- a/tests/allure_behave/acceptance/behave_support/scenarios/scenario_test.py
+++ b/tests/allure_behave/acceptance/behave_support/scenarios/scenario_test.py
@@ -1,9 +1,14 @@
 import pytest
 from hamcrest import assert_that
+from hamcrest import contains_string
+from hamcrest import all_of
 from tests.allure_behave.behave_runner import AllureBehaveRunner
 from allure_commons_test.report import has_test_case
 from allure_commons_test.result import with_status
 from allure_commons_test.result import has_step
+from allure_commons_test.result import has_full_name
+from allure_commons_test.result import has_test_case_id
+from allure_commons_test.result import has_history_id
 
 
 @pytest.mark.parametrize(["step", "status"], [
@@ -140,3 +145,32 @@ def test_nameless_scenario(docstring, behave_runner: AllureBehaveRunner):
             with_status("passed")
         )
     )
+
+
+def test_identifiers_are_set(docstring, behave_runner: AllureBehaveRunner):
+    """
+    Feature: Foo
+
+    Scenario: Bar:
+      Given noop
+    """
+
+    behave_runner.run_behave(
+        feature_literals=[docstring],
+        step_literals=["given('noop')(lambda c:None)"]
+    )
+
+    assert_that(
+        behave_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_full_name(
+                all_of(
+                    contains_string("Foo"),
+                    contains_string("Bar"),
+                ),
+            ),
+            has_test_case_id(),
+            has_history_id(),
+        ),
+    )
diff --git a/tests/allure_behave/acceptance/behave_support/titlepath/__init__.py b/tests/allure_behave/acceptance/behave_support/titlepath/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_behave/acceptance/behave_support/titlepath/titlepath_test.py b/tests/allure_behave/acceptance/behave_support/titlepath/titlepath_test.py
new file mode 100644
index 00000000..7e035a3f
--- /dev/null
+++ b/tests/allure_behave/acceptance/behave_support/titlepath/titlepath_test.py
@@ -0,0 +1,110 @@
+from pathlib import Path
+from hamcrest import assert_that
+from tests.allure_behave.behave_runner import AllureBehaveRunner
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_title_path
+
+
+def test_titlepath_of_top_level_feature_file(docstring, behave_runner: AllureBehaveRunner):
+    """
+    Feature: Foo
+    Scenario: Bar
+        Given baz
+    """
+
+    behave_runner.run_behave(
+        feature_files={"foo.feature": docstring},
+        step_literals=["given('baz')(lambda c:None)"],
+    )
+
+    assert_that(
+        behave_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("Foo"),
+        )
+    )
+
+
+def test_titlepath_of_nested_feature_file(docstring, behave_runner: AllureBehaveRunner):
+    """
+    Feature: Foo
+    Scenario: Bar
+        Given baz
+    """
+
+    behave_runner.run_behave(
+        feature_files={"foo/bar/baz.feature": docstring},
+        step_literals=["given('baz')(lambda c:None)"],
+    )
+
+    assert_that(
+        behave_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("foo", "bar", "Foo"),
+        )
+    )
+
+
+def test_titlepath_if_feature_name_empty(docstring, behave_runner: AllureBehaveRunner):
+    """
+    Feature:
+    Scenario: Bar
+        Given baz
+    """
+
+    behave_runner.run_behave(
+        feature_files={str(Path("foo.feature").absolute()): docstring},
+        step_literals=["given('baz')(lambda c:None)"],
+    )
+
+    assert_that(
+        behave_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("foo.feature"),
+        )
+    )
+
+
+def test_titlepath_of_feature_without_filename(docstring, behave_runner: AllureBehaveRunner):
+    """
+    Feature: Foo
+    Scenario: Bar
+        Given baz
+    """
+
+    behave_runner.run_behave(
+        feature_literals=[docstring],
+        step_literals=["given('baz')(lambda c:None)"],
+    )
+
+    assert_that(
+        behave_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("Foo"),
+        )
+    )
+
+
+def test_titlepath_of_feature_without_filename_and_name(docstring, behave_runner: AllureBehaveRunner):
+    """
+    Feature:
+    Scenario: Bar
+        Given baz
+    """
+
+    behave_runner.run_behave(
+        feature_literals=[docstring],
+        step_literals=["given('baz')(lambda c:None)"],
+    )
+
+    assert_that(
+        behave_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("Feature"),
+        )
+    )
diff --git a/tests/allure_behave/behave_runner.py b/tests/allure_behave/behave_runner.py
index da49d738..1cbaf845 100644
--- a/tests/allure_behave/behave_runner.py
+++ b/tests/allure_behave/behave_runner.py
@@ -11,7 +11,7 @@
 from behave.step_registry import setup_step_decorators
 from behave.step_registry import StepRegistry
 from pytest import FixtureRequest, Pytester
-from typing import Sequence
+from typing import Sequence, Mapping
 from tests.e2e import AllureFrameworkRunner, PathlikeT
 
 from allure_behave.formatter import AllureFormatter
@@ -91,7 +91,10 @@ def load_step_definitions(self, extra_step_paths=None):
 
     def load_features(self):
         self.features.extend(
-            parse_feature(f) for f in self.__features
+            parse_feature(feature) if isinstance(feature, str) else parse_feature(
+                feature[1],
+                filename=feature[0],
+            ) for feature in self.__features
         )
 
     def load_formatter(self):
@@ -123,6 +126,7 @@ def run_behave(
         feature_paths: Sequence[PathlikeT] = None,
         feature_literals: Sequence[str] = None,
         feature_rst_ids: Sequence[str] = None,
+        feature_files: Mapping[str, str] = None,
         step_paths: Sequence[PathlikeT] = None,
         step_literals: Sequence[str] = None,
         step_rst_ids: Sequence[str] = None,
@@ -172,7 +176,7 @@ def run_behave(
                     paths=feature_paths,
                     literals=feature_literals,
                     rst_ids=feature_rst_ids
-                ),
+                ) + list((feature_files or {}).items()),
                 self._get_all_content(
                     paths=step_paths,
                     literals=step_literals,
diff --git a/tests/allure_behave/defects/issue717_test.py b/tests/allure_behave/defects/issue717_test.py
index cfd5f371..0a85f23f 100644
--- a/tests/allure_behave/defects/issue717_test.py
+++ b/tests/allure_behave/defects/issue717_test.py
@@ -44,7 +44,7 @@ def __init__(self, content):
     pytest.param(
         [
             ["a"],
-            ["\""]
+            ['"']
         ],
         id="quote"
     ),
@@ -58,7 +58,7 @@ def __init__(self, content):
     pytest.param(
         [
             ["a", "b"],
-            ["\"1\",2", "3\",4"]
+            ['"1",2', '3",4']
         ],
         id="mix"
     )
diff --git a/tests/allure_nose2/acceptance/nose2_support/titlepath/__init__.py b/tests/allure_nose2/acceptance/nose2_support/titlepath/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_nose2/acceptance/nose2_support/titlepath/titlepath_test.py b/tests/allure_nose2/acceptance/nose2_support/titlepath/titlepath_test.py
new file mode 100644
index 00000000..004c866b
--- /dev/null
+++ b/tests/allure_nose2/acceptance/nose2_support/titlepath/titlepath_test.py
@@ -0,0 +1,71 @@
+import pytest
+from hamcrest import assert_that
+from tests.allure_nose2.nose2_runner import AllureNose2Runner
+
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_title_path
+
+
+@pytest.mark.parametrize(["module", "path_segments"], [
+    pytest.param("foo", ["foo"], id="root"),
+    pytest.param("foo.bar", ["foo", "bar"], id="level1"),
+    pytest.param("foo.bar.baz", ["foo", "bar", "baz"], id="level2"),
+])
+def test_function_title_path(nose2_runner: AllureNose2Runner, module, path_segments):
+    """
+    >>> def test_qux():
+    ...     pass
+    """
+
+    allure_results = nose2_runner.run_docstring(module_name=module)
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_qux",
+            has_title_path(*path_segments),
+        )
+    )
+
+
+@pytest.mark.parametrize(["module", "path_segments"], [
+    pytest.param("foo", ["foo"], id="root"),
+    pytest.param("foo.bar", ["foo", "bar"], id="level1"),
+    pytest.param("foo.bar.baz", ["foo", "bar", "baz"], id="level2"),
+])
+def test_method_title_path(nose2_runner: AllureNose2Runner, module, path_segments):
+    """
+    >>> from unittest import TestCase
+    >>> class TestQux(TestCase):
+    ...     def test_quux(self):
+    ...         pass
+    """
+
+    allure_results = nose2_runner.run_docstring(module_name=module)
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_quux",
+            has_title_path(*path_segments, "TestQux"),
+        )
+    )
+
+
+def test_params_ignored(nose2_runner: AllureNose2Runner):
+    """
+    >>> from nose2.tools import params
+    >>> @params("a.b:c")
+    ... def test_bar(v):
+    ...     pass
+    """
+
+    allure_results = nose2_runner.run_docstring(module_name="foo")
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_bar",
+            has_title_path("foo"),
+        )
+    )
diff --git a/tests/allure_nose2/nose2_runner.py b/tests/allure_nose2/nose2_runner.py
index 67b35d7e..e5cf1802 100644
--- a/tests/allure_nose2/nose2_runner.py
+++ b/tests/allure_nose2/nose2_runner.py
@@ -12,10 +12,10 @@ class AllureNose2Runner(AllureFrameworkRunner):
     def __init__(self, request: FixtureRequest, pytester: Pytester):
         super().__init__(request, pytester, AllureNose2Runner.LOGGER_PATH)
 
-    def run_docstring(self):
+    def run_docstring(self, module_name=None):
         docstring = self._find_docstring()
         example_code = script_from_examples(docstring)
-        spec = importlib.machinery.ModuleSpec(self.request.node.name, None)
+        spec = importlib.machinery.ModuleSpec(module_name or self.request.node.name, None)
         module = importlib.util.module_from_spec(spec)
         return self._run(module, example_code)
 
diff --git a/tests/allure_pytest/acceptance/fixture/fixture_test.py b/tests/allure_pytest/acceptance/fixture/fixture_test.py
index 68562282..5b931a38 100644
--- a/tests/allure_pytest/acceptance/fixture/fixture_test.py
+++ b/tests/allure_pytest/acceptance/fixture/fixture_test.py
@@ -1,5 +1,5 @@
 import pytest
-from hamcrest import assert_that, not_, all_of
+from hamcrest import assert_that, not_, all_of, matches_regexp
 from itertools import combinations_with_replacement
 from tests.allure_pytest.pytest_runner import AllurePytestRunner
 
@@ -287,7 +287,7 @@ def test_with_redefined_fixture(my_fixture):
                     has_step("Step in before in original fixture")
                 ),
                 has_after(
-                    "my_fixture::0",
+                    matches_regexp(r"^my_fixture::\d+$"),
                     has_step("Step in after in original fixture")
                 )
             ),
@@ -298,7 +298,7 @@ def test_with_redefined_fixture(my_fixture):
                     has_step("Step in before in redefined fixture")
                 ),
                 has_after(
-                    "my_fixture::0",
+                    matches_regexp(r"^my_fixture::\d+$"),
                     has_step("Step in after in redefined fixture")
                 )
             )
@@ -356,18 +356,24 @@ def test_three(request):
                 has_container(
                     allure_results,
                     has_before("parent_auto_call_fixture"),
-                    has_after("parent_auto_call_fixture::0")
+                    has_after(
+                        matches_regexp(r"^parent_auto_call_fixture::\d$")
+                    )
                 ),
                 has_container(
                     allure_results,
                     has_before("child_manual_call_fixture"),
-                    has_after("child_manual_call_fixture::0")
+                    has_after(
+                        matches_regexp(r"^child_manual_call_fixture::\d$")
+                    )
                 ),
                 not_(
                     has_container(
                         allure_results,
                         has_before("parent_dyn_call_fixture"),
-                        has_after("parent_dyn_call_fixture::0")
+                        has_after(
+                            matches_regexp(r"^parent_dyn_call_fixture::\d$")
+                        )
                     ),
                 ),
                 not_(
@@ -382,19 +388,25 @@ def test_three(request):
                 has_container(
                     allure_results,
                     has_before("parent_auto_call_fixture"),
-                    has_after("parent_auto_call_fixture::0")
+                    has_after(
+                        matches_regexp(r"^parent_auto_call_fixture::\d$")
+                    )
                 ),
                 not_(
                     has_container(
                         allure_results,
                         has_before("child_manual_call_fixture"),
-                        has_after("child_manual_call_fixture::0")
+                        has_after(
+                            matches_regexp(r"^child_manual_call_fixture::\d$")
+                        )
                     ),
                 ),
                 has_container(
                     allure_results,
                     has_before("parent_dyn_call_fixture"),
-                    has_after("parent_dyn_call_fixture::0")
+                    has_after(
+                        matches_regexp(r"^parent_dyn_call_fixture::\d$")
+                    ),
                 ),
                 has_container(
                     allure_results,
@@ -406,19 +418,25 @@ def test_three(request):
                 has_container(
                     allure_results,
                     has_before("parent_auto_call_fixture"),
-                    has_after("parent_auto_call_fixture::0")
+                    has_after(
+                        matches_regexp(r"^parent_auto_call_fixture::\d$")
+                    )
                 ),
                 not_(
                     has_container(
                         allure_results,
                         has_before("child_manual_call_fixture"),
-                        has_after("child_manual_call_fixture::0")
+                        has_after(
+                            matches_regexp(r"^child_manual_call_fixture::\d$")
+                        )
                     ),
                 ),
                 has_container(
                     allure_results,
                     has_before("parent_dyn_call_fixture"),
-                    has_after("parent_dyn_call_fixture::0")
+                    has_after(
+                        matches_regexp(r"^parent_dyn_call_fixture::\d$")
+                    )
                 ),
                 not_(
                     has_container(
diff --git a/tests/allure_pytest/acceptance/globals/__init__.py b/tests/allure_pytest/acceptance/globals/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_pytest/acceptance/globals/globals_test.py b/tests/allure_pytest/acceptance/globals/globals_test.py
new file mode 100644
index 00000000..e3fc9f62
--- /dev/null
+++ b/tests/allure_pytest/acceptance/globals/globals_test.py
@@ -0,0 +1,142 @@
+from hamcrest import assert_that, has_item, all_of
+from hamcrest import equal_to, ends_with, has_length
+from tests.allure_pytest.pytest_runner import AllurePytestRunner
+
+from allure_commons_test.result import has_global_attachment_with_content
+from allure_commons_test.result import has_global_error
+from allure_commons_test.result import with_message_contains
+from allure_commons_test.result import with_trace_contains
+from allure_commons_test.result import with_no_trace
+from allure_commons_test.result import with_status
+
+
+def test_globals_from_session_hooks(allure_pytest_runner: AllurePytestRunner):
+    allure_results = allure_pytest_runner.run_pytest(
+        """
+        def test_globals_from_session_hooks():
+            pass
+        """,
+        conftest_literal=(
+            """
+            import allure
+
+
+            def pytest_sessionstart(session):
+                allure.global_attach(body="global body", name="global attachment")
+                allure.global_attach.file(__file__, name="global attachment file")
+                allure.global_error("message only error")
+
+
+            def pytest_sessionfinish(session, exitstatus):
+                try:
+                    raise ValueError("error from exception")
+                except ValueError as error:
+                    allure.global_error(error)
+                allure.global_error("message with trace", "explicit trace")
+            """
+        )
+    )
+
+    assert_that(
+        allure_results.globals,
+        has_length(5),
+    )
+
+    assert_that(
+        allure_results.globals,
+        all_of(
+            has_item(
+                has_global_attachment_with_content(
+                    allure_results.attachments,
+                    equal_to("global body"),
+                    name="global attachment"
+                )
+            ),
+            has_item(
+                has_global_attachment_with_content(
+                    allure_results.attachments,
+                    ends_with("conftest.py"),
+                    name="global attachment file"
+                )
+            ),
+            has_item(
+                has_global_error(
+                    with_message_contains("message only error"),
+                    with_no_trace(),
+                    with_status("broken"),
+                )
+            ),
+            has_item(
+                has_global_error(
+                    with_message_contains("ValueError: error from exception"),
+                    with_trace_contains("raise ValueError"),
+                    with_status("broken"),
+                )
+            ),
+            has_item(
+                has_global_error(
+                    with_message_contains("message with trace"),
+                    with_trace_contains("explicit trace"),
+                    with_status("broken"),
+                )
+            )
+        )
+    )
+
+
+def test_global_error_support_status(allure_pytest_runner: AllurePytestRunner):
+    allure_results = allure_pytest_runner.run_pytest(
+        """
+        def test_globals_from_session_hooks():
+            pass
+        """,
+        conftest_literal=(
+            """
+            import allure
+
+
+            def pytest_sessionstart(session):
+                allure.global_error("message only error", status = allure.error_status.FAILED)
+
+
+            def pytest_sessionfinish(session, exitstatus):
+                try:
+                    raise ValueError("error from exception")
+                except ValueError as error:
+                    allure.global_error(error, status = allure.error_status.FAILED)
+                allure.global_error("message with trace", "explicit trace", status = allure.error_status.FAILED)
+            """
+        )
+    )
+
+    assert_that(
+        allure_results.globals,
+        has_length(3),
+    )
+
+    assert_that(
+        allure_results.globals,
+        all_of(
+            has_item(
+                has_global_error(
+                    with_message_contains("message only error"),
+                    with_no_trace(),
+                    with_status("failed"),
+                )
+            ),
+            has_item(
+                has_global_error(
+                    with_message_contains("ValueError: error from exception"),
+                    with_trace_contains("raise ValueError"),
+                    with_status("failed"),
+                )
+            ),
+            has_item(
+                has_global_error(
+                    with_message_contains("message with trace"),
+                    with_trace_contains("explicit trace"),
+                    with_status("failed"),
+                )
+            )
+        )
+    )
diff --git a/tests/allure_pytest/acceptance/label/package/package_test.py b/tests/allure_pytest/acceptance/label/package/package_test.py
new file mode 100644
index 00000000..7acbdc72
--- /dev/null
+++ b/tests/allure_pytest/acceptance/label/package/package_test.py
@@ -0,0 +1,39 @@
+from hamcrest import assert_that
+from tests.allure_pytest.pytest_runner import AllurePytestRunner
+
+from allure_commons_test.report import has_test_case
+from allure_commons_test.label import has_package
+
+
+def test_with_no_package(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> def test_bar(request):
+    ...     pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename="foo_test.py")
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_bar",
+            has_package("foo_test")
+        )
+    )
+
+
+def test_with_package(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> def test_qux(request):
+    ...     pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename="foo/bar/baz_test.py")
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_qux",
+            has_package("foo.bar.baz_test"),
+        )
+    )
diff --git a/tests/allure_pytest/acceptance/label/package/regression_test.py b/tests/allure_pytest/acceptance/label/package/regression_test.py
index 42c90d31..ba8f5ecb 100644
--- a/tests/allure_pytest/acceptance/label/package/regression_test.py
+++ b/tests/allure_pytest/acceptance/label/package/regression_test.py
@@ -26,22 +26,3 @@ def test_path_with_dots_test_example():
             has_package("path.with.dots.test_path")
         )
     )
-
-
-def test_with_no_package(allure_pytest_runner: AllurePytestRunner):
-    """
-    >>> def test_package_less(request):
-    ...     pass
-    """
-
-    allure_pytest_runner.pytester.makeini("""[pytest]""")
-
-    allure_results = allure_pytest_runner.run_docstring()
-
-    assert_that(
-        allure_results,
-        has_test_case(
-            "test_package_less",
-            has_package("test_with_no_package")
-        )
-    )
diff --git a/tests/allure_pytest/acceptance/label/tag/tag_test.py b/tests/allure_pytest/acceptance/label/tag/tag_test.py
index 3f32475b..a738628b 100644
--- a/tests/allure_pytest/acceptance/label/tag/tag_test.py
+++ b/tests/allure_pytest/acceptance/label/tag/tag_test.py
@@ -1,17 +1,19 @@
-from hamcrest import assert_that, not_
+from hamcrest import assert_that, not_, anything
 from tests.allure_pytest.pytest_runner import AllurePytestRunner
 
 from allure_commons_test.report import has_test_case
 from allure_commons_test.label import has_tag
 
 
-def test_pytest_marker(allure_pytest_runner: AllurePytestRunner):
+def test_pytest_simple_markers_are_converted_to_allure_tags(
+        allure_pytest_runner: AllurePytestRunner
+):
     """
     >>> import pytest
 
     >>> @pytest.mark.cool
     ... @pytest.mark.stuff
-    ... def test_pytest_marker_example():
+    ... def test_pytest_simple_markers_are_converted_to_allure_tags_example():
     ...     pass
     """
 
@@ -20,25 +22,21 @@ def test_pytest_marker(allure_pytest_runner: AllurePytestRunner):
     assert_that(
         allure_results,
         has_test_case(
-            "test_pytest_marker_example",
+            "test_pytest_simple_markers_are_converted_to_allure_tags_example",
             has_tag("cool"),
             has_tag("stuff")
         )
     )
 
 
-def test_show_reserved_pytest_markers_full_decorator(
-    allure_pytest_runner: AllurePytestRunner
+def test_pytest_marker_with_args_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
 ):
     """
     >>> import pytest
 
-    >>> @pytest.mark.usermark1
-    ... @pytest.mark.usermark2
-    ... @pytest.mark.parametrize("param", ["foo"])
-    ... @pytest.mark.skipif(False, reason="reason2")
-    ... @pytest.mark.skipif(False, reason="reason1")
-    ... def test_show_reserved_pytest_markers_full_decorator_example(param):
+    >>> @pytest.mark.marker('cool', 'stuff')
+    ... def test_pytest_marker_with_args_is_not_converted_to_allure_tag_example():
     ...     pass
     """
 
@@ -47,26 +45,46 @@ def test_show_reserved_pytest_markers_full_decorator(
     assert_that(
         allure_results,
         has_test_case(
-            "test_show_reserved_pytest_markers_full_decorator_example[foo]",
-            has_tag("usermark1"),
-            has_tag("usermark2"),
-            has_tag("@pytest.mark.skipif(False, reason='reason1')"),
+            "test_pytest_marker_with_args_is_not_converted_to_allure_tag_example",
             not_(
-                has_tag("@pytest.mark.skipif(False, reason='reason2')")
-            ),
+                has_tag(anything())
+            )
+        )
+    )
+
+
+def test_pytest_marker_with_kwargs_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
+):
+    """
+    >>> import pytest
+
+    >>> @pytest.mark.marker(stuff='cool')
+    ... def test_pytest_marker_with_kwargs_is_not_converted_to_allure_tag_example():
+    ...     pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring()
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_pytest_marker_with_kwargs_is_not_converted_to_allure_tag_example",
             not_(
-                has_tag("@pytest.mark.parametrize('param', ['foo'])")
+                has_tag(anything())
             )
         )
     )
 
 
-def test_pytest_xfail_marker(allure_pytest_runner: AllurePytestRunner):
+def test_pytest_reserved_marker_usefixtures_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
+):
     """
     >>> import pytest
 
-    >>> @pytest.mark.xfail(reason='this is unexpect pass')
-    ... def test_pytest_xfail_marker_example():
+    >>> @pytest.mark.usefixtures('test_fixture')
+    ... def test_pytest_reserved_marker_usefixtures_is_not_converted_to_allure_tag_example():
     ...     pass
     """
 
@@ -75,18 +93,22 @@ def test_pytest_xfail_marker(allure_pytest_runner: AllurePytestRunner):
     assert_that(
         allure_results,
         has_test_case(
-            "test_pytest_xfail_marker_example",
-            has_tag("@pytest.mark.xfail(reason='this is unexpect pass')")
+            "test_pytest_reserved_marker_usefixtures_is_not_converted_to_allure_tag_example",
+            not_(
+                has_tag(anything())
+            )
         )
     )
 
 
-def test_pytest_marker_with_args(allure_pytest_runner: AllurePytestRunner):
+def test_pytest_reserved_marker_filterwarnings_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
+):
     """
     >>> import pytest
 
-    >>> @pytest.mark.marker('cool', 'stuff')
-    ... def test_pytest_marker_with_args_example():
+    >>> @pytest.mark.filterwarnings('ignore:val')
+    ... def test_pytest_reserved_marker_filterwarnings_is_not_converted_to_allure_tag_example():
     ...     pass
     """
 
@@ -95,18 +117,22 @@ def test_pytest_marker_with_args(allure_pytest_runner: AllurePytestRunner):
     assert_that(
         allure_results,
         has_test_case(
-            "test_pytest_marker_with_args_example",
-            has_tag("marker('cool', 'stuff')")
+            "test_pytest_reserved_marker_filterwarnings_is_not_converted_to_allure_tag_example",
+            not_(
+                has_tag(anything())
+            )
         )
     )
 
 
-def test_pytest_marker_with_kwargs(allure_pytest_runner: AllurePytestRunner):
+def test_pytest_reserved_marker_skip_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
+):
     """
     >>> import pytest
 
-    >>> @pytest.mark.marker(stuff='cool')
-    ... def test_pytest_marker_with_kwargs_example():
+    >>> @pytest.mark.skip(reason='reason')
+    ... def test_pytest_reserved_marker_skip_is_not_converted_to_allure_tag_example():
     ...     pass
     """
 
@@ -115,20 +141,22 @@ def test_pytest_marker_with_kwargs(allure_pytest_runner: AllurePytestRunner):
     assert_that(
         allure_results,
         has_test_case(
-            "test_pytest_marker_with_kwargs_example",
-            has_tag("marker(stuff='cool')")
+            "test_pytest_reserved_marker_skip_is_not_converted_to_allure_tag_example",
+            not_(
+                has_tag(anything())
+            )
         )
     )
 
 
-def test_pytest_marker_with_kwargs_native_encoding(
-    allure_pytest_runner: AllurePytestRunner
+def test_pytest_reserved_marker_skipif_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
 ):
     """
     >>> import pytest
 
-    >>> @pytest.mark.marker(stuff='я')
-    ... def test_pytest_marker_with_kwargs_native_encoding_example():
+    >>> @pytest.mark.skipif(False, reason='reason')
+    ... def test_pytest_reserved_marker_skipif_is_not_converted_to_allure_tag_example():
     ...     pass
     """
 
@@ -137,20 +165,22 @@ def test_pytest_marker_with_kwargs_native_encoding(
     assert_that(
         allure_results,
         has_test_case(
-            "test_pytest_marker_with_kwargs_native_encoding_example",
-            has_tag("marker(stuff='я')")
+            "test_pytest_reserved_marker_skipif_is_not_converted_to_allure_tag_example",
+            not_(
+                has_tag(anything())
+            )
         )
     )
 
 
-def test_pytest_marker_with_kwargs_utf_encoding(
-    allure_pytest_runner: AllurePytestRunner
+def test_pytest_reserved_marker_xfail_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
 ):
     """
     >>> import pytest
 
-    >>> @pytest.mark.marker(stuff='я')
-    ... def test_pytest_marker_with_kwargs_utf_encoding_example():
+    >>> @pytest.mark.xfail(reason='this is unexpect pass')
+    ... def test_pytest_reserved_marker_xfail_is_not_converted_to_allure_tag_example():
     ...     pass
     """
 
@@ -159,7 +189,33 @@ def test_pytest_marker_with_kwargs_utf_encoding(
     assert_that(
         allure_results,
         has_test_case(
-            "test_pytest_marker_with_kwargs_utf_encoding_example",
-            has_tag("marker(stuff='я')")
+            "test_pytest_reserved_marker_xfail_is_not_converted_to_allure_tag_example",
+            not_(
+                has_tag(anything())
+            )
+        )
+    )
+
+
+def test_pytest_reserved_marker_parametrize_is_not_converted_to_allure_tag(
+        allure_pytest_runner: AllurePytestRunner
+):
+    """
+    >>> import pytest
+
+    >>> @pytest.mark.parametrize("param", ["foo"])
+    ... def test_pytest_reserved_marker_parametrize_is_not_converted_to_allure_tag_example(param):
+    ...     pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring()
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_pytest_reserved_marker_parametrize_is_not_converted_to_allure_tag_example[foo]",
+            not_(
+                has_tag(anything())
+            )
         )
     )
diff --git a/tests/allure_pytest/acceptance/link/dynamic_link_test.py b/tests/allure_pytest/acceptance/link/dynamic_link_test.py
index d8390a77..c63fb661 100644
--- a/tests/allure_pytest/acceptance/link/dynamic_link_test.py
+++ b/tests/allure_pytest/acceptance/link/dynamic_link_test.py
@@ -64,10 +64,10 @@ def test_unique_dynamic_links(allure_pytest_runner: AllurePytestRunner):
     allure_results = allure_pytest_runner.run_docstring()
 
     assert_that(
-        allure_results.test_cases[0]['links'],
+        allure_results.test_cases[0]["links"],
         equal_to([{
-            'url': 'some/unique/dynamic/link',
-            'type': 'link',
-            'name': 'some/unique/dynamic/link'
+            "url": "some/unique/dynamic/link",
+            "type": "link",
+            "name": "some/unique/dynamic/link"
         }])
     )
diff --git a/tests/allure_pytest/acceptance/parametrization/parametrization_test.py b/tests/allure_pytest/acceptance/parametrization/parametrization_test.py
index 07d7ac3b..2e7a754b 100644
--- a/tests/allure_pytest/acceptance/parametrization/parametrization_test.py
+++ b/tests/allure_pytest/acceptance/parametrization/parametrization_test.py
@@ -198,7 +198,7 @@ def test_dynamic_parameter_mode(allure_pytest_runner: AllurePytestRunner):
             has_parameter(
                 "param1",
                 "'param-value'",
-                with_mode('masked')
+                with_mode("masked")
             )
         )
     )
@@ -271,7 +271,7 @@ def test_fullname_with_braces(allure_pytest_runner: AllurePytestRunner):
         has_test_case(
             "test_with_braces[qwe][]",
             has_entry(
-                'fullName',
+                "fullName",
                 ends_with(".TestClass#test_with_braces")
             ),
             has_parameter("param1", "'qwe]['")
diff --git a/tests/allure_pytest/acceptance/results/results_test.py b/tests/allure_pytest/acceptance/results/results_test.py
index 39c996c3..edf072e4 100644
--- a/tests/allure_pytest/acceptance/results/results_test.py
+++ b/tests/allure_pytest/acceptance/results/results_test.py
@@ -17,8 +17,8 @@ def test_custom_alluredir(allure_pytest_runner: AllurePytestRunner):
             TEST_FUNC,
             cli_args=["--alluredir", "allure_results"]
         )
-    assert (alluredir / 'allure_results').exists()
-    results = AllureReport(alluredir / 'allure_results')
+    assert (alluredir / "allure_results").exists()
+    results = AllureReport(alluredir / "allure_results")
     assert len(results.test_cases) == 2
 
 
@@ -33,7 +33,7 @@ def test_clean_alluredir(allure_pytest_runner: AllurePytestRunner):
             TEST_FUNC,
             cli_args=["--alluredir", "allure_results", "--clean-alluredir"]
         )
-    results = AllureReport(alluredir / 'allure_results')
+    results = AllureReport(alluredir / "allure_results")
     assert len(results.test_cases) == 1
 
 
@@ -46,12 +46,12 @@ def test_clean_alluredir_with_collectonly(allure_pytest_runner: AllurePytestRunn
         TEST_FUNC,
         cli_args=["--alluredir", "allure_results"]
     )
-    results_before_clean = AllureReport(alluredir / 'allure_results')
+    results_before_clean = AllureReport(alluredir / "allure_results")
     # run test with --collectonly
     allure_pytest_runner.run_pytest(
         TEST_FUNC,
         cli_args=["--alluredir", "allure_results", "--clean-alluredir", "--collectonly"]
     )
     # results should be the same
-    results_after_clean = AllureReport(alluredir / 'allure_results')
+    results_after_clean = AllureReport(alluredir / "allure_results")
     assert results_before_clean.test_cases == results_after_clean.test_cases
diff --git a/tests/allure_pytest/acceptance/status/base_step_status_test.py b/tests/allure_pytest/acceptance/status/base_step_status_test.py
index c5cb1a06..dcf39a5a 100644
--- a/tests/allure_pytest/acceptance/status/base_step_status_test.py
+++ b/tests/allure_pytest/acceptance/status/base_step_status_test.py
@@ -91,14 +91,14 @@ def test_pytest_bytes_data_in_assert(allure_pytest_runner: AllurePytestRunner):
             "test_pytest_bytes_data_in_assert_example",
             with_status("failed"),
             has_status_details(
-                with_message_contains("AssertionError: assert \'0\\x82\' == 1"),
+                with_message_contains("AssertionError: assert '0\\x82' == 1"),
                 with_trace_contains("def test_pytest_bytes_data_in_assert_example():")
             ),
             has_step(
                 "Step",
                 with_status("failed"),
                 has_status_details(
-                    with_message_contains("AssertionError: assert \'0\\x82\' == 1"),
+                    with_message_contains("AssertionError: assert '0\\x82' == 1"),
                     with_trace_contains("test_pytest_bytes_data_in_assert_example")
                 )
             )
diff --git a/tests/allure_pytest/acceptance/titlepath/__init__.py b/tests/allure_pytest/acceptance/titlepath/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_pytest/acceptance/titlepath/titlepath_test.py b/tests/allure_pytest/acceptance/titlepath/titlepath_test.py
new file mode 100644
index 00000000..f731cedd
--- /dev/null
+++ b/tests/allure_pytest/acceptance/titlepath/titlepath_test.py
@@ -0,0 +1,75 @@
+import pytest
+from hamcrest import assert_that
+from tests.allure_pytest.pytest_runner import AllurePytestRunner
+
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_title_path
+
+
+@pytest.mark.parametrize(["path", "path_segments"], [
+    pytest.param("foo_test.py", ["foo_test.py"], id="root"),
+    pytest.param("foo/bar_test.py", ["foo", "bar_test.py"], id="dir"),
+    pytest.param("foo/bar/baz_test.py", ["foo", "bar", "baz_test.py"], id="subdir"),
+])
+def test_function_title_path(allure_pytest_runner: AllurePytestRunner, path, path_segments):
+    """
+    >>> def test_bar():
+    ...     pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename=path)
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_bar",
+            has_title_path(*path_segments),
+        )
+    )
+
+
+@pytest.mark.parametrize(["path", "path_segments"], [
+    pytest.param("foo_test.py", ["foo_test.py"], id="root"),
+    pytest.param("foo/bar_test.py", ["foo", "bar_test.py"], id="dir"),
+    pytest.param("foo/bar/baz_test.py", ["foo", "bar", "baz_test.py"], id="subdir"),
+])
+def test_method_title_path(allure_pytest_runner: AllurePytestRunner, path, path_segments):
+    """
+    >>> class TestBar:
+    ...     def test_baz(self):
+    ...         pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename=path)
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_baz",
+            has_title_path(*path_segments, "TestBar"),
+        )
+    )
+
+
+@pytest.mark.parametrize(["path", "path_segments"], [
+    pytest.param("foo_test.py", ["foo_test.py"], id="root"),
+    pytest.param("foo/bar_test.py", ["foo", "bar_test.py"], id="dir"),
+    pytest.param("foo/bar/baz_test.py", ["foo", "bar", "baz_test.py"], id="subdir"),
+])
+def test_nested_class_method_title_path(allure_pytest_runner: AllurePytestRunner, path, path_segments):
+    """
+    >>> class TestBar:
+    ...     class TestBaz:
+    ...         def test_qux(self):
+    ...             pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename=path)
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_qux",
+            has_title_path(*path_segments, "TestBar", "TestBaz"),
+        )
+    )
diff --git a/tests/allure_pytest/defects/issue868_test.py b/tests/allure_pytest/defects/issue868_test.py
new file mode 100644
index 00000000..82db7689
--- /dev/null
+++ b/tests/allure_pytest/defects/issue868_test.py
@@ -0,0 +1,47 @@
+import allure
+from hamcrest import assert_that, is_not
+from tests.allure_pytest.pytest_runner import AllurePytestRunner
+
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_full_name
+from allure_commons_test.label import has_sub_suite
+
+
+@allure.issue("868", name="Issue 868")
+def test_nested_class_affects_fullname_and_subsuite(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> class TestFoo:
+    ...     class TestBar:
+    ...         def test_bar(self):
+    ...             pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename="foo_test.py")
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_bar",
+            has_full_name("foo_test.TestFoo.TestBar#test_bar"),
+            has_sub_suite("TestFoo > TestBar"),
+        ),
+    )
+
+
+@allure.issue("868", name="Issue 868")
+def test_nested_class_affects_testcaseid_and_historyid(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> class TestFoo:
+    ...     class TestFoo:
+    ...         def test_foo(self):
+    ...             pass
+    ...     def test_foo(self):
+    ...         pass
+    """
+
+    allure_results = allure_pytest_runner.run_docstring(filename="foo_test.py")
+    test_case_id1, test_case_id2 = [tc["testCaseId"] for tc in allure_results.test_cases]
+    history_id1, history_id2 = [tc["historyId"] for tc in allure_results.test_cases]
+
+    assert_that(test_case_id1, is_not(test_case_id2))
+    assert_that(history_id1, is_not(history_id2))
diff --git a/tests/allure_pytest/externals/pytest_rerunfailures/pytest_rerunfailures_test.py b/tests/allure_pytest/externals/pytest_rerunfailures/pytest_rerunfailures_test.py
index b242b488..779657c3 100644
--- a/tests/allure_pytest/externals/pytest_rerunfailures/pytest_rerunfailures_test.py
+++ b/tests/allure_pytest/externals/pytest_rerunfailures/pytest_rerunfailures_test.py
@@ -65,6 +65,6 @@ def __count_labels(tc, name):
 
     assert len(output.test_cases) == 2
     assert __count_labels(output.test_cases[0], "suite") == 1
-    assert __count_labels(output.test_cases[0], "tag") == 1
+    assert __count_labels(output.test_cases[0], "tag") == 0
     assert __count_labels(output.test_cases[1], "suite") == 1
-    assert __count_labels(output.test_cases[1], "tag") == 1
+    assert __count_labels(output.test_cases[1], "tag") == 0
diff --git a/tests/allure_pytest_bdd/acceptance/globals_test.py b/tests/allure_pytest_bdd/acceptance/globals_test.py
new file mode 100644
index 00000000..5e0d5a34
--- /dev/null
+++ b/tests/allure_pytest_bdd/acceptance/globals_test.py
@@ -0,0 +1,122 @@
+from hamcrest import assert_that
+from hamcrest import equal_to
+from hamcrest import has_item
+from hamcrest import has_length
+
+from allure_commons_test.result import has_global_attachment_with_content
+from allure_commons_test.result import has_global_error
+from allure_commons_test.result import with_message_contains
+from allure_commons_test.result import with_status
+
+from tests.allure_pytest.pytest_runner import AllurePytestRunner
+
+
+def test_global_attachment_and_error_from_hook(allure_pytest_bdd_runner: AllurePytestRunner):
+    feature_content = (
+        """
+        Feature: Foo
+            Scenario: Bar
+                Given noop
+        """
+    )
+    steps_content = (
+        """
+        from pytest_bdd import scenario, given
+
+        @scenario("sample.feature", "Bar")
+        def test_scenario():
+            pass
+
+        @given("noop")
+        def given_noop():
+            pass
+        """
+    )
+    conftest_content = (
+        """
+        import allure
+
+        def pytest_sessionstart(session):
+            allure.global_attach("bdd global attachment", name="bdd global")
+
+        def pytest_sessionfinish(session, exitstatus):
+            allure.global_error("bdd global error")
+        """
+    )
+
+    allure_results = allure_pytest_bdd_runner.run_pytest(
+        ("sample.feature", feature_content),
+        steps_content,
+        conftest_literal=conftest_content,
+    )
+
+    assert_that(allure_results.globals, has_length(2))
+
+    assert_that(
+        allure_results.globals,
+        has_item(
+            has_global_attachment_with_content(
+                allure_results.attachments,
+                equal_to("bdd global attachment"),
+                name="bdd global",
+            )
+        )
+    )
+    assert_that(
+        allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("bdd global error"),
+                with_status("broken"),
+            )
+        )
+    )
+
+
+def test_global_error_support_status_overwrite(allure_pytest_bdd_runner: AllurePytestRunner):
+    feature_content = (
+        """
+        Feature: Foo
+            Scenario: Bar
+                Given noop
+        """
+    )
+    steps_content = (
+        """
+        from pytest_bdd import scenario, given
+
+        @scenario("sample.feature", "Bar")
+        def test_scenario():
+            pass
+
+        @given("noop")
+        def given_noop():
+            pass
+        """
+    )
+    conftest_content = (
+        """
+        import allure
+
+        def pytest_sessionfinish(session, exitstatus):
+            allure.global_error("bdd global error", status = allure.error_status.FAILED)
+        """
+    )
+
+    allure_results = allure_pytest_bdd_runner.run_pytest(
+        ("sample.feature", feature_content),
+        steps_content,
+        conftest_literal=conftest_content,
+    )
+
+    assert_that(allure_results.globals, has_length(1))
+
+    assert_that(
+        allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("bdd global error"),
+                with_status("failed"),
+            )
+        )
+    )
diff --git a/tests/allure_pytest_bdd/acceptance/results/results_test.py b/tests/allure_pytest_bdd/acceptance/results/results_test.py
index f8f35d2c..7e5cfc39 100644
--- a/tests/allure_pytest_bdd/acceptance/results/results_test.py
+++ b/tests/allure_pytest_bdd/acceptance/results/results_test.py
@@ -47,8 +47,8 @@ def test_custom_alluredir(allure_pytest_bdd_runner: AllurePytestRunner):
             STEPS_CONTENT,
             cli_args=["--alluredir", "allure_results"]
         )
-    assert (alluredir / 'allure_results').exists()
-    results = AllureReport(alluredir / 'allure_results')
+    assert (alluredir / "allure_results").exists()
+    results = AllureReport(alluredir / "allure_results")
     assert len(results.test_cases) == 2
 
 
@@ -64,7 +64,7 @@ def test_clean_alluredir(allure_pytest_bdd_runner: AllurePytestRunner):
             STEPS_CONTENT,
             cli_args=["--alluredir", "allure_results", "--clean-alluredir"]
         )
-    results = AllureReport(alluredir / 'allure_results')
+    results = AllureReport(alluredir / "allure_results")
     assert len(results.test_cases) == 1
 
 
@@ -78,7 +78,7 @@ def test_clean_alluredir_with_collectonly(allure_pytest_bdd_runner: AllurePytest
         STEPS_CONTENT,
         cli_args=["--alluredir", "allure_results"]
     )
-    results_before_clean = AllureReport(alluredir / 'allure_results')
+    results_before_clean = AllureReport(alluredir / "allure_results")
     # run test with --collectonly
     allure_pytest_bdd_runner.run_pytest(
         ("scenario.feature", FEATURE_CONTENT),
@@ -86,5 +86,5 @@ def test_clean_alluredir_with_collectonly(allure_pytest_bdd_runner: AllurePytest
         cli_args=["--alluredir", "allure_results", "--clean-alluredir", "--collectonly"]
     )
     # results should be the same
-    results_after_clean = AllureReport(alluredir / 'allure_results')
+    results_after_clean = AllureReport(alluredir / "allure_results")
     assert results_before_clean.test_cases == results_after_clean.test_cases
diff --git a/tests/allure_pytest_bdd/acceptance/scenario_test.py b/tests/allure_pytest_bdd/acceptance/scenario_test.py
index a381f088..fe648eed 100644
--- a/tests/allure_pytest_bdd/acceptance/scenario_test.py
+++ b/tests/allure_pytest_bdd/acceptance/scenario_test.py
@@ -1,6 +1,7 @@
 """ ./allure-pytest-bdd/examples/simple-scenario """
 
-from hamcrest import assert_that
+from allure import issue
+from hamcrest import assert_that, not_, equal_to
 from tests.allure_pytest.pytest_runner import AllurePytestRunner
 from allure_commons_test.report import has_test_case
 from allure_commons_test.result import with_status
@@ -42,7 +43,7 @@ def then_the_postconditions_are_held():
 
     output = allure_pytest_bdd_runner.run_pytest(
         ("scenario.feature", feature_content),
-        steps_content
+        steps_content,
     )
 
     assert_that(
@@ -56,3 +57,40 @@ def then_the_postconditions_are_held():
             has_history_id()
         )
     )
+
+@issue("925")
+def test_uuid_not_reused_across_runs(allure_pytest_bdd_runner: AllurePytestRunner):
+    feature_content = (
+        """
+        Feature: Foo
+            Scenario: Bar
+                Given noop
+        """
+    )
+    steps_content = (
+        """
+        from pytest_bdd import scenario, given, when, then
+
+        @scenario("foo.feature", "Bar")
+        def test_bar():
+            pass
+
+        @given("noop")
+        def given_noop():
+            pass
+        """
+    )
+
+    output1 = allure_pytest_bdd_runner.run_pytest(
+        ("foo.feature", feature_content),
+        steps_content
+    )
+    output2 = allure_pytest_bdd_runner.run_pytest(
+        ("foo.feature", feature_content),
+        steps_content
+    )
+
+    uuid1 = output1.test_cases[0]["uuid"]
+    uuid2 = output2.test_cases[0]["uuid"]
+
+    assert_that(uuid1, not_(equal_to(uuid2)))
diff --git a/tests/allure_pytest_bdd/acceptance/steps/gherkin_steps_test.py b/tests/allure_pytest_bdd/acceptance/steps/gherkin_steps_test.py
index 268e20a3..3249c028 100644
--- a/tests/allure_pytest_bdd/acceptance/steps/gherkin_steps_test.py
+++ b/tests/allure_pytest_bdd/acceptance/steps/gherkin_steps_test.py
@@ -457,7 +457,7 @@ def then_skip():
                     has_title("Given unknown"),
                     with_status("broken"),
                     has_status_details(
-                        with_message_contains("Step definition is not found: Given \"unknown\""),
+                        with_message_contains('Step definition is not found: Given "unknown"'),
                     ),
                 ),
                 all_of(
diff --git a/tests/allure_pytest_bdd/acceptance/titlepath/__init__.py b/tests/allure_pytest_bdd/acceptance/titlepath/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_pytest_bdd/acceptance/titlepath/titlepath_test.py b/tests/allure_pytest_bdd/acceptance/titlepath/titlepath_test.py
new file mode 100644
index 00000000..60ee2363
--- /dev/null
+++ b/tests/allure_pytest_bdd/acceptance/titlepath/titlepath_test.py
@@ -0,0 +1,91 @@
+import pytest
+from hamcrest import assert_that
+from tests.allure_pytest.pytest_runner import AllurePytestRunner
+import allure
+
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_title_path
+
+
+@pytest.mark.parametrize(["path", "path_segments"], [
+    pytest.param("foo.feature", ["Qux"], id="root"),
+    pytest.param("foo/bar.feature", ["foo", "Qux"], id="dir"),
+    pytest.param("foo/bar/baz.feature", ["foo", "bar", "Qux"], id="subdir"),
+])
+def test_title_path(allure_pytest_bdd_runner: AllurePytestRunner, path, path_segments):
+    allure.dynamic.parent_suite("my suite")
+    allure.dynamic.suite("my suite")
+    allure.dynamic.sub_suite("my suite")
+
+    allure.dynamic.epic("my suite")
+    allure.dynamic.feature("my suite")
+    allure.dynamic.story("my suite")
+
+    feature_content = (
+        """
+        Feature: Qux
+            Scenario: Quux
+                Given pass
+        """
+    )
+    pytest_content = (
+        f"""
+        from pytest_bdd import scenarios, given
+        import allure
+
+        scenarios("{path}")
+
+        @given("pass")
+        def given_pass():
+            pass
+        """
+    )
+
+    allure_results = allure_pytest_bdd_runner.run_pytest(
+        (path, feature_content),
+        pytest_content,
+    )
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "Quux",
+            has_title_path(*path_segments),
+        )
+    )
+
+
+def test_feature_name_missing(allure_pytest_bdd_runner: AllurePytestRunner):
+    feature_content = (
+        """
+        Feature:
+            Scenario: Bar
+                Given pass
+        """
+    )
+    pytest_content = (
+        """
+        from pytest_bdd import scenarios, given
+        import allure
+
+        scenarios("foo.feature")
+
+        @given("pass")
+        def given_pass():
+            pass
+        """
+    )
+
+    allure_results = allure_pytest_bdd_runner.run_pytest(
+        ("foo.feature", feature_content),
+        pytest_content,
+        cli_args=["--capture=no"]
+    )
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("foo.feature"),
+        )
+    )
diff --git a/tests/allure_robotframework/acceptance/allure_api/globals/__init__.py b/tests/allure_robotframework/acceptance/allure_api/globals/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_robotframework/acceptance/allure_api/globals/globals_test.py b/tests/allure_robotframework/acceptance/allure_api/globals/globals_test.py
new file mode 100644
index 00000000..40f7c414
--- /dev/null
+++ b/tests/allure_robotframework/acceptance/allure_api/globals/globals_test.py
@@ -0,0 +1,130 @@
+""" ./allure-robotframework/examples/attachment.rst """
+
+from hamcrest import assert_that, equal_to, has_item, has_length
+from tests.allure_robotframework.robot_runner import AllureRobotRunner
+from allure_commons_test.result import has_global_attachment_with_content
+from allure_commons_test.result import has_global_error
+from allure_commons_test.result import with_message_contains
+from allure_commons_test.result import with_status
+
+
+def test_global_attachment_and_error(robot_runner: AllureRobotRunner):
+    robot_runner.run_robotframework(
+        suite_literals={
+            "global-attachment.robot": (
+                """
+                *** Settings ***
+                Library     AllureLibrary
+                Library     ./lib.py
+                Suite Setup     Global Attach    robot global attachment    name=robot global
+                Suite Teardown  Global Error     robot global error
+
+                *** Test Cases ***
+                Global Attachment
+                    Add Globals From Code
+                """
+            ),
+        },
+        library_literals={
+            "lib.py": (
+                """
+                import allure
+
+                def add_globals_from_code():
+                    allure.global_attach(body="global body", name="global attachment")
+                    allure.global_error("message only error")
+                """
+            ),
+        },
+    )
+
+    assert_that(robot_runner.allure_results.globals, has_length(4))
+
+    assert_that(
+        robot_runner.allure_results.globals,
+        has_item(
+            has_global_attachment_with_content(
+                robot_runner.allure_results.attachments,
+                equal_to("robot global attachment"),
+                name="robot global"
+            )
+        )
+    )
+    assert_that(
+        robot_runner.allure_results.globals,
+        has_item(
+            has_global_attachment_with_content(
+                robot_runner.allure_results.attachments,
+                equal_to("global body"),
+                name="global attachment"
+            )
+        )
+    )
+    assert_that(
+        robot_runner.allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("robot global error"),
+                with_status("broken"),
+            )
+        )
+    )
+    assert_that(
+        robot_runner.allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("message only error"),
+                with_status("broken"),
+            )
+        )
+    )
+
+
+def test_global_error_status_can_be_overwritten(robot_runner: AllureRobotRunner):
+    robot_runner.run_robotframework(
+        suite_literals={
+            "global-attachment.robot": (
+                """
+                *** Settings ***
+                Library     AllureLibrary
+                Library     ./lib.py
+                Suite Teardown  Global Error     robot global error     status=failed
+
+                *** Test Cases ***
+                Global Attachment
+                    Add Globals From Code
+                """
+            ),
+        },
+        library_literals={
+            "lib.py": (
+                """
+                import allure
+
+                def add_globals_from_code():
+                    allure.global_error("message only error", status=allure.error_status.FAILED)
+                """
+            ),
+        },
+    )
+
+    assert_that(robot_runner.allure_results.globals, has_length(2))
+
+    assert_that(
+        robot_runner.allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("robot global error"),
+                with_status("failed"),
+            )
+        )
+    )
+    assert_that(
+        robot_runner.allure_results.globals,
+        has_item(
+            has_global_error(
+                with_message_contains("message only error"),
+                with_status("failed"),
+            )
+        )
+    )
diff --git a/tests/allure_robotframework/acceptance/robotframework_support/identifiers_test.py b/tests/allure_robotframework/acceptance/robotframework_support/identifiers_test.py
new file mode 100644
index 00000000..92a3899f
--- /dev/null
+++ b/tests/allure_robotframework/acceptance/robotframework_support/identifiers_test.py
@@ -0,0 +1,35 @@
+from hamcrest import assert_that
+from hamcrest import all_of
+from hamcrest import contains_string
+from tests.allure_robotframework.robot_runner import AllureRobotRunner
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_full_name
+from allure_commons_test.result import has_test_case_id
+from allure_commons_test.result import has_history_id
+
+
+def test_identifiers_are_set(docstring, robot_runner: AllureRobotRunner):
+    """
+    *** Test Cases ***
+    Foo
+        No Operation
+    """
+
+    robot_runner.run_robotframework(
+        suite_literals={"Bar.robot": docstring}
+    )
+
+    assert_that(
+        robot_runner.allure_results,
+        has_test_case(
+            "Foo",
+            has_full_name(
+                all_of(
+                    contains_string("Foo"),
+                    contains_string("Bar"),
+                ),
+            ),
+            has_test_case_id(),
+            has_history_id(),
+        )
+    )
diff --git a/tests/allure_robotframework/acceptance/robotframework_support/statuses/statuses_test.py b/tests/allure_robotframework/acceptance/robotframework_support/statuses/statuses_test.py
index 51d06aef..cc712987 100644
--- a/tests/allure_robotframework/acceptance/robotframework_support/statuses/statuses_test.py
+++ b/tests/allure_robotframework/acceptance/robotframework_support/statuses/statuses_test.py
@@ -63,14 +63,14 @@ def test_failed_in_library(docstring, robot_runner: AllureRobotRunner):
             with_status("failed"),
             has_status_details(
                 with_message_contains("Reason"),
-                with_trace_contains("library.py\", line 3, in fail_in_library")
+                with_trace_contains('library.py", line 3, in fail_in_library')
             ),
             has_step(
                 "library.Fail In Library",
                 with_status("failed"),
                 has_status_details(
                     with_message_contains("Reason"),
-                    with_trace_contains("library.py\", line 3, in fail_in_library")
+                    with_trace_contains('library.py", line 3, in fail_in_library')
                 )
             )
         )
@@ -111,7 +111,7 @@ def test_only_failed_steps_have_status_details(docstring, robot_runner: AllureRo
         FOR    ${value}    IN    @{TEST_VALUES}
             Run Keyword And Ignore Error    Should Be True    ${value} > 10
         END
-        Log To Console    Test message
+        No Operation
     """
 
     robot_runner.run_robotframework(
@@ -163,7 +163,7 @@ def test_only_failed_steps_have_status_details(docstring, robot_runner: AllureRo
                 )
             ),
             has_step(
-                "BuiltIn.Log To Console",
+                "BuiltIn.No Operation",
                 with_status("passed"),
                 has_status_details({})
             )
diff --git a/tests/allure_robotframework/acceptance/robotframework_support/titlepath/__init__.py b/tests/allure_robotframework/acceptance/robotframework_support/titlepath/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/allure_robotframework/acceptance/robotframework_support/titlepath/titlepath_test.py b/tests/allure_robotframework/acceptance/robotframework_support/titlepath/titlepath_test.py
new file mode 100644
index 00000000..24a88064
--- /dev/null
+++ b/tests/allure_robotframework/acceptance/robotframework_support/titlepath/titlepath_test.py
@@ -0,0 +1,56 @@
+from hamcrest import assert_that, all_of
+from tests.allure_robotframework.robot_runner import AllureRobotRunner
+from allure_commons_test.report import has_test_case
+from allure_commons_test.result import has_title_path
+
+
+def test_titlepath_of_directly_run_suite(docstring, robot_runner: AllureRobotRunner):
+    """
+    *** Test Cases ***
+    Bar
+        No Operation
+    """
+
+    robot_runner.run_robotframework(
+        suite_literals={"foo.robot": docstring}
+    )
+
+    assert_that(
+        robot_runner.allure_results,
+        has_test_case(
+            "Bar",
+            has_title_path("Foo"),
+        )
+    )
+
+
+def test_titlepath_of_nested_suites(docstring, robot_runner: AllureRobotRunner):
+    """
+    *** Test Cases ***
+    Qux
+        No Operation
+    """
+
+    robot_runner.rootdir = "foo"
+
+    robot_runner.run_robotframework(
+        suite_literals={
+            "foo/bar/baz.robot": docstring,
+            "foo/bor/buz.robot": docstring,
+        }
+
+    )
+
+    assert_that(
+        robot_runner.allure_results,
+        all_of(
+            has_test_case(
+                "Foo.Bar.Baz.Qux",
+                has_title_path("Foo", "Bar", "Baz"),
+            ),
+            has_test_case(
+                "Foo.Bor.Buz.Qux",
+                has_title_path("Foo", "Bor", "Buz"),
+            ),
+        ),
+    )
diff --git a/tests/allure_robotframework/robot_runner.py b/tests/allure_robotframework/robot_runner.py
index bfb13cee..1d019ffe 100644
--- a/tests/allure_robotframework/robot_runner.py
+++ b/tests/allure_robotframework/robot_runner.py
@@ -1,7 +1,7 @@
 import robot
 from pytest import FixtureRequest, Pytester
 from tests.e2e import AllureFrameworkRunner, PathlikeT
-from typing import Sequence, Mapping
+from typing import Sequence, Mapping, Union
 from allure_robotframework import allure_robotframework
 
 
@@ -12,6 +12,7 @@ class AllureRobotRunner(AllureFrameworkRunner):
 
     def __init__(self, request: FixtureRequest, pytester: Pytester):
         super().__init__(request, pytester, AllureRobotRunner.LOGGER_PATH)
+        self.rootdir: Union[str, None] = None
 
     def run_robotframework(
         self,
@@ -79,7 +80,7 @@ def run_robotframework(
         )
 
     def _run_framework(self, suites, options):
-        robot.run(*suites, listener=allure_robotframework(None), **options)
+        robot.run(*[self.rootdir] if self.rootdir else suites, listener=allure_robotframework(None), **options)
 
     def __resolve_options(self, options):
         return {