diff --git a/src/Standards/Generic/Sniffs/Files/LineLengthSniff.php b/src/Standards/Generic/Sniffs/Files/LineLengthSniff.php
index ba05bb08e4..04f4d67004 100644
--- a/src/Standards/Generic/Sniffs/Files/LineLengthSniff.php
+++ b/src/Standards/Generic/Sniffs/Files/LineLengthSniff.php
@@ -177,21 +177,62 @@ protected function checkLineLength(File $phpcsFile, array $tokens, int $stackPtr
         if ($this->absoluteLineLimit > 0
             && $lineLength > $this->absoluteLineLimit
         ) {
+            $code = 'MaxExceeded';
+            if ($this->isNamespacedNameExceedingLength($tokens, $stackPtr, $this->absoluteLineLimit) === true) {
+                $code = 'NamespacedNameMaxExceeded';
+            }
+
             $data = [
                 $this->absoluteLineLimit,
                 $lineLength,
             ];
 
             $error = 'Line exceeds maximum limit of %s characters; contains %s characters';
-            $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data);
+            $phpcsFile->addError($error, $stackPtr, $code, $data);
         } elseif ($lineLength > $this->lineLimit) {
+            $code = 'TooLong';
+            if ($this->isNamespacedNameExceedingLength($tokens, $stackPtr, $this->lineLimit) === true) {
+                $code = 'NamespacedNameTooLong';
+            }
+
             $data = [
                 $this->lineLimit,
                 $lineLength,
             ];
 
             $warning = 'Line exceeds %s characters; contains %s characters';
-            $phpcsFile->addWarning($warning, $stackPtr, 'TooLong', $data);
+            $phpcsFile->addWarning($warning, $stackPtr, $code, $data);
         }
     }
+
+
+    /**
+     * Checks if a line is a namespaced name
+     *
+     * @param array $tokens    The token stack.
+     * @param int   $stackPtr  The last token on the line.
+     * @param int   $lineLimit The line limit.
+     *
+     * @return bool
+     */
+    private function isNamespacedNameExceedingLength(array $tokens, int $stackPtr, int $lineLimit): bool
+    {
+        $line = $tokens[$stackPtr]['line'];
+
+        for ($i = $stackPtr; $tokens[$i]['line'] === $line; $i--) {
+            $length = ($tokens[$i]['column'] + $tokens[$i]['length'] - 1);
+
+            // Check the line limit of the namespaced name is equal or over the line length. This check accounts for the
+            // fact that namespaced names are or closed by ; or opened by ( or {.
+            if ($length >= $lineLimit
+                && ($tokens[$i]['code'] === T_NAME_QUALIFIED
+                || $tokens[$i]['code'] === T_NAME_FULLY_QUALIFIED
+                || $tokens[$i]['code'] === T_NAME_RELATIVE)
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }
diff --git a/src/Standards/Generic/Tests/Files/LineLengthUnitTest.5.inc b/src/Standards/Generic/Tests/Files/LineLengthUnitTest.5.inc
new file mode 100644
index 0000000000..9c72008b63
--- /dev/null
+++ b/src/Standards/Generic/Tests/Files/LineLengthUnitTest.5.inc
@@ -0,0 +1,45 @@
+<?php
+
+// This is just within the limit
+namespace This\Name\Space\IsGoingToBeJustWithinLimits\LongLongLongLongLongLoong;
+
+// This is just within the absolute limit and should throw a NamespacedNameTooLong warning
+namespace This\Name\Space\IsGoingToBeJustWithinLimits\LongLongLongLongLongLongLongLongLongLongLongLongLongLongLoooooong;
+
+// This is too long and should throw a NamespacedNameMaxExceeded error
+namespace This\Name\Space\IsGoingToBeTooLong\LongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLongLoooong;
+
+// These are just within the limits
+use ThisReallyLong\Looooooooooooooong\UseStatement\ShouldBeNotTooLong\ClassName;
+use function ThisReallyLong\Looong\UseStatement\ShouldBeNotTooLong\functionCall;
+use const ThisReallyLong\Loooooooooong\UseStatement\ShouldBeNotTooLong\CONSTANT;
+
+// These are just a bit too long and should throw a NamespacedNameTooLong warning
+use ThisReallyLong\Long\Looooong\Looooooooooooooong\UseStatement\ThatShouldThrowAWarning\BecauseItsNotTooLong\ClassName;
+use function ThisReallyLong\Long\Looooooong\Long\UseStatement\ThatShouldThrowAWarning\BecauseItsNotTooLong\functionCall;
+use const ThisReallyLong\Long\Looooong\Loooooooooong\UseStatement\ThatShouldThrowAWarning\BecauseItsNotTooLong\CONSTANT;
+
+// These are just a bit too long and should throw a NamespacedNameMaxExceeded error
+use ThisReallyLong\Long\Loooooong\Looooong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\ClassName;
+use function ThisReallyLong\Long\Looong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\functionCall;
+use const ThisReallyLong\Long\Loooooooooong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\CONSTANT;
+
+// These are just within the limits
+echo \This\Name\Space\IsGoingToBeJustWithinLimits\LongLongLooong\functionCall();
+new \This\Name\Space\IsGoingToBeJustWithinLimits\LongLongLongLooong\ClassName();
+
+// These are just a bit too long and should throw a NamespacedNameTooLong warning
+echo \ThisReallyLong\Long\Looooong\Loooooooong\UseStatement\ThatShouldThrowAWarning\BecauseItsNotTooLong\functionCall();
+new \ThisReallyLong\Long\Looooong\Loooooooooooong\UseStatement\ThatShouldThrowAWarning\BecauseItsNotTooLong\ClassName();
+
+// These are just a bit too long and should throw a NamespacedNameMaxExceeded error
+echo \ThisReallyLong\Long\Long\Looooong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\functionCall();
+new \ThisReallyLong\Long\Long\Looooooooong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\ClassName();
+
+// These are a bit too long but can be shortened and should throw a TooLong warning
+echo \This\Name\Space\IsGoingToBeJustWithinLimits\LongLongLooong\functionCall('foo', 'bar', 'baz');
+new \This\Name\Space\IsGoingToBeJustWithinLimits\LongLongLongLooong\ClassName('foo', 'bar', 'baz');
+
+// These are just a bit too long but can be shortened and should throw a MaxExceeded error
+echo \ThisReallyLong\Long\Long\Looong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\functionCall('foo', 'bar', 'baz');
+new \ThisReallyLong\Long\Long\Looooooong\UseStatement\ThatShouldNotBeAllowed\AndThrowErrorsBecauseItsTooLong\ClassName('foo', 'bar', 'baz');
diff --git a/src/Standards/Generic/Tests/Files/LineLengthUnitTest.php b/src/Standards/Generic/Tests/Files/LineLengthUnitTest.php
index c52defea74..892b58a606 100644
--- a/src/Standards/Generic/Tests/Files/LineLengthUnitTest.php
+++ b/src/Standards/Generic/Tests/Files/LineLengthUnitTest.php
@@ -60,6 +60,17 @@ public function getErrorList($testFile = '')
             case 'LineLengthUnitTest.2.inc':
             case 'LineLengthUnitTest.3.inc':
                 return [7 => 1];
+            case 'LineLengthUnitTest.5.inc':
+                return [
+                    10 => 1,
+                    23 => 1,
+                    24 => 1,
+                    25 => 1,
+                    36 => 1,
+                    37 => 1,
+                    44 => 1,
+                    45 => 1,
+                ];
 
             default:
                 return [];
@@ -103,6 +114,17 @@ public function getWarningList($testFile = '')
                     10 => 1,
                     14 => 1,
                 ];
+            case 'LineLengthUnitTest.5.inc':
+                return [
+                    7  => 1,
+                    18 => 1,
+                    19 => 1,
+                    20 => 1,
+                    32 => 1,
+                    33 => 1,
+                    40 => 1,
+                    41 => 1,
+                ];
 
             default:
                 return [];